Cataclysm BN
game Class Reference

#include <game.h>

Classes

class  Creature_range
 
class  debug_hour_timer
 
class  draw_callback_t
 
class  monster_range
 
class  non_dead_range
 
class  npc_range
 

Public Member Functions

 game ()
 
 ~game ()
 
void load_static_data ()
 Loads static data that does not depend on mods or similar. More...
 
void load_core_data (loading_ui &ui)
 Loads core dynamic data. More...
 
bool is_core_data_loaded () const
 Returns whether the core data is currently loaded. More...
 
bool check_mod_data (const std::vector< mod_id > &opts, loading_ui &ui)
 Check if mods can be successfully loaded. More...
 
void load_world_modfiles (loading_ui &ui)
 Loads core data and mods from the active world. More...
 
std::string get_player_base_save_path () const
 Base path for saving player data. More...
 
std::string get_world_base_save_path () const
 Base path for saving world data. More...
 
bool load_packs (const std::string &msg, const std::vector< mod_id > &packs, loading_ui &ui)
 Load content packs. More...
 
void on_options_changed ()
 Should be invoked whenever options change. More...
 
void setup ()
 
void serialize (std::ostream &fout)
 Saving and loading functions. More...
 
void unserialize (std::istream &fin)
 
void unserialize_master (std::istream &fin)
 
bool dump_stats (const std::string &what, dump_mode mode, const std::vector< std::string > &opts)
 write statistics to stdout and More...
 
bool save ()
 Returns false if saving failed. More...
 
std::vector< std::string > list_active_characters ()
 Returns a list of currently active character saves. More...
 
void write_memorial_file (const std::string &filename, std::string sLastWords)
 Writes information about the character out to a text file timestamped with the time of the file was made. More...
 
bool cleanup_at_end ()
 
void start_calendar ()
 
bool do_turn ()
 MAIN GAME LOOP. More...
 
shared_ptr_fast< ui_adaptorcreate_or_get_main_ui_adaptor ()
 
void invalidate_main_ui_adaptor () const
 
void mark_main_ui_adaptor_resize () const
 
void draw ()
 
void draw_ter (bool draw_sounds=true)
 
void draw_ter (const tripoint &center, bool looking=false, bool draw_sounds=true)
 
void add_draw_callback (shared_ptr_fast< draw_callback_t > cb)
 
void draw_panels (bool force_draw=false)
 
cata::optional< tripointget_veh_dir_indicator_location (bool next) const
 Returns the location where the indicator should go relative to the reality bubble, or nothing to indicate no indicator should be drawn. More...
 
void draw_veh_dir_indicator (bool next)
 
void vertical_move (int z, bool force, bool peeking=false)
 Moves the player vertically. More...
 
void start_hauling (const tripoint &pos)
 
cata::optional< tripointfind_or_make_stairs (map &mp, int z_after, bool &rope_ladder, bool peeking)
 Returns the other end of the stairs (if any). More...
 
void vertical_shift (int z_after)
 Actual z-level movement part of vertical_move. More...
 
void vertical_notes (int z_before, int z_after)
 Add goes up/down auto_notes (if turned on) More...
 
void use_computer (const tripoint &p)
 Checks to see if a player can use a computer (not illiterate, etc.) and uses if able. More...
 
template<typename T = Creature>
T * critter_by_id (const character_id &id)
 
template<typename T = Creature>
T * critter_at (const tripoint &p, bool allow_hallucination=false)
 Returns the Creature at the given location. More...
 
template<typename T = Creature>
const T * critter_at (const tripoint &p, bool allow_hallucination=false) const
 
template<typename T = Creature>
shared_ptr_fast< T > shared_from (const T &critter)
 Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature). More...
 
size_t num_creatures () const
 Returns the approximate number of creatures in the reality bubble. More...
 
bool update_zombie_pos (const monster &critter, const tripoint &pos)
 Redirects to the creature_tracker update_pos() function. More...
 
void remove_zombie (const monster &critter)
 
void clear_zombies ()
 Redirects to the creature_tracker clear() function. More...
 
bool spawn_hallucination (const tripoint &p)
 Spawns a hallucination at a determined position. More...
 
bool swap_critters (Creature &, Creature &)
 Swaps positions of two creatures. More...
 
Creature_range all_creatures ()
 Returns an anonymous range that contains all creatures. More...
 
monster_range all_monsters ()
 Same as all_creatures but iterators only over monsters. More...
 
npc_range all_npcs ()
 Same as all_creatures but iterators only over npcs. More...
 
std::vector< Creature * > get_creatures_if (const std::function< bool(const Creature &)> &pred)
 Returns all creatures matching a predicate. More...
 
std::vector< npc * > get_npcs_if (const std::function< bool(const npc &)> &pred)
 
Creatureget_creature_if (const std::function< bool(const Creature &)> &pred)
 Returns a creature matching a predicate. More...
 
bool is_empty (const tripoint &p)
 Returns true if there is no player, NPC, or monster on the tile and move_cost > 0. More...
 
bool is_in_sunlight (const tripoint &p)
 Returns true if p is outdoors and it is sunny. More...
 
bool is_sheltered (const tripoint &p)
 Returns true if p is indoors, underground, or in a car. More...
 
bool revive_corpse (const tripoint &p, item &it)
 Revives a corpse at given location. More...
 
void save_cyborg (item *cyborg, const tripoint &couch_pos, player &installer)
 Turns Broken Cyborg monster into Cyborg NPC via surgery. More...
 
bool cancel_activity_query (const std::string &text)
 Asks if the player wants to cancel their activity, and if so cancels it. More...
 
bool cancel_activity_or_ignore_query (distraction_type type, const std::string &text)
 Asks if the player wants to cancel their activity and if so cancels it. More...
 
void moving_vehicle_dismount (const tripoint &dest_loc)
 Handles players exiting from moving vehicles. More...
 
vehicleremoteveh ()
 Returns the current remotely controlled vehicle. More...
 
void setremoteveh (vehicle *veh)
 Sets the current remotely controlled vehicle. More...
 
int assign_mission_id ()
 Returns the next available mission id. More...
 
npcfind_npc (character_id id)
 Find the npc with the given ID. More...
 
void load_npcs ()
 Makes any nearby NPCs on the overmap active. More...
 
void reload_npcs ()
 Unloads, then loads the NPCs. More...
 
const kill_trackerget_kill_tracker () const
 
void add_npc_follower (const character_id &id)
 Add follower id to set of followers. More...
 
void remove_npc_follower (const character_id &id)
 Remove follower id from follower set. More...
 
std::set< character_idget_follower_list ()
 Get set of followers. More...
 
void validate_npc_followers ()
 validate list of followers to account for overmap buffers More...
 
void validate_mounted_npcs ()
 
void validate_linked_vehicles ()
 validate towed vehicles so they get linked up again after a load More...
 
void validate_camps ()
 validate camps to ensure they are on the overmap list More...
 
void autopilot_vehicles ()
 process vehicles that are following the player More...
 
void catch_a_monster (monster *fish, const tripoint &pos, player *p, const time_duration &catch_duration)
 Picks and spawns a random fish from the remaining fish list when a fish is caught. More...
 
std::unordered_set< tripointget_fishable_locations (int distance, const tripoint &fish_pos)
 Get the contiguous fishable locations starting at fish_pos, out to the specificed distance. More...
 
std::vector< monster * > get_fishable_monsters (std::unordered_set< tripoint > &fishable_locations)
 Get the fishable monsters within the provided fishable locations. More...
 
void fling_creature (Creature *c, const units::angle &dir, float flvel, bool controlled=false, bool suppress_map_update=false)
 Flings the input creature in the given direction. More...
 
float natural_light_level (int zlev) const
 
unsigned char light_level (int zlev) const
 Returns coarse number-of-squares of visibility at the current light level. More...
 
void reset_light_level ()
 
character_id assign_npc_id ()
 
Creatureis_hostile_nearby ()
 
Creatureis_hostile_very_close ()
 
point update_map (player &p)
 
point update_map (int &x, int &y)
 
void update_overmap_seen ()
 
void process_artifact (item &it, player &p)
 
void add_artifact_messages (const std::vector< art_effect_passive > &effects)
 
void add_artifact_dreams ()
 
void peek ()
 
void peek (const tripoint &p)
 
cata::optional< tripointlook_debug ()
 
bool check_zone (const zone_type_id &type, const tripoint &where) const
 
bool check_near_zone (const zone_type_id &type, const tripoint &where) const
 Checks whether or not there is a zone of particular type nearby. More...
 
bool is_zones_manager_open () const
 
void zones_manager ()
 
cata::optional< tripointlook_around (bool force_3d=false)
 
look_around_result look_around (bool show_window, tripoint &center, const tripoint &start_point, bool has_first_point, bool select_zone, bool peeking, bool is_moving_zone=false, const tripoint &end_point=tripoint_zero, bool force_3d=false)
 
void pre_print_all_tile_info (const tripoint &lp, const catacurses::window &w_info, int &line, int last_line, const visibility_variables &cache)
 
void print_all_tile_info (const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line, int last_line, const visibility_variables &cache)
 
void draw_look_around_cursor (const tripoint &lp, const visibility_variables &cache)
 
void extended_description (const tripoint &p)
 Long description of (visible) things at tile. More...
 
void draw_trail_to_square (const tripoint &t, bool bDrawX)
 
item_location inv_map_splice (item_filter filter, const std::string &title, int radius=0, const std::string &none_message="")
 Custom-filtered menu for inventory and nearby items and those that within specified radius. More...
 
bool has_gametype () const
 
special_game_id gametype () const
 
void toggle_fullscreen ()
 
void toggle_pixel_minimap ()
 
void reload_tileset ()
 
void temp_exit_fullscreen ()
 
void reenter_fullscreen ()
 
void zoom_in ()
 
void zoom_out ()
 
void reset_zoom ()
 
void set_zoom (int level)
 
int get_zoom () const
 
int get_moves_since_last_save () const
 
int get_user_action_counter () const
 
bool take_screenshot (const std::string &file_path) const
 Saves a screenshot of the current viewport, as a PNG file, to the given location. More...
 
bool take_screenshot () const
 Saves a screenshot of the current viewport, as a PNG file. More...
 
int get_levx () const
 The top left corner of the reality bubble (in submaps coordinates). More...
 
int get_levy () const
 
int get_levz () const
 
void load_map (const tripoint &pos_sm, bool pump_events=false)
 Load the main map at given location, see map::load, in global, absolute submap coordinates. More...
 
void load_map (const tripoint_abs_sm &pos_sm, bool pump_events=false)
 
overmapget_cur_om () const
 The overmap which contains the center submap of the reality bubble. More...
 
std::vector< npc * > allies ()
 Get all living player allies. More...
 
void set_driving_view_offset (const point &p)
 
void calc_driving_offset (vehicle *veh=nullptr)
 
void toggle_gate (const tripoint &p)
 
void knockback (const tripoint &s, const tripoint &t, int force, int stun, int dam_mult, Creature *source)
 
void knockback (std::vector< tripoint > &traj, int stun, int dam_mult, Creature *source)
 
void draw_bullet (const tripoint &t, int i, const std::vector< tripoint > &trajectory, char bullet)
 
void draw_hit_mon (const tripoint &p, const monster &m, bool dead=false)
 
void draw_hit_player (const Character &p, int dam)
 
void draw_line (const tripoint &p, const tripoint &center_point, const std::vector< tripoint > &points, bool noreveal=false)
 
void draw_line (const tripoint &p, const std::vector< tripoint > &points)
 
void draw_weather (const weather_printable &wPrint)
 
void draw_sct ()
 
void draw_zones (const tripoint &start, const tripoint &end, const tripoint &offset)
 
void draw_critter (const Creature &critter, const tripoint &center)
 
void draw_critter_highlighted (const Creature &critter, const tripoint &center)
 
void draw_cursor (const tripoint &p)
 
void draw_highlight (const tripoint &p)
 
void draw_radiation_override (const tripoint &p, int rad)
 
void draw_terrain_override (const tripoint &p, const ter_id &id)
 
void draw_furniture_override (const tripoint &p, const furn_id &id)
 
void draw_graffiti_override (const tripoint &p, bool has)
 
void draw_trap_override (const tripoint &p, const trap_id &id)
 
void draw_field_override (const tripoint &p, const field_type_id &id)
 
void draw_item_override (const tripoint &p, const itype_id &id, const mtype_id &mid, bool hilite)
 
void draw_vpart_override (const tripoint &p, const vpart_id &id, int part_mod, units::angle veh_dir, bool hilite, const point &mount)
 
void draw_below_override (const tripoint &p, bool draw)
 
void draw_monster_override (const tripoint &p, const mtype_id &id, int count, bool more, Creature::Attitude att)
 
bool is_in_viewport (const tripoint &p, int margin=0) const
 
bool check_safe_mode_allowed (bool repeat_safe_mode_warnings=true)
 Check whether movement is allowed according to safe mode settings. More...
 
void set_safe_mode (safe_mode_type mode)
 
void exam_vehicle (vehicle &veh, const point &cp=point_zero)
 open vehicle interaction screen More...
 
bool forced_door_closing (const tripoint &p, const ter_id &door_type, int bash_dmg)
 
bool load (const std::string &world)
 Attempt to load first valid save (if any) in world. More...
 
bool npc_menu (npc &who)
 Returns true if the menu handled stuff and player shouldn't do anything else. More...
 
bool phasing_move (const tripoint &dest, bool via_ramp=false)
 
bool walk_move (const tripoint &dest, bool via_ramp=false)
 
void on_move_effects ()
 
point place_player (const tripoint &dest)
 
void place_player_overmap (const tripoint_abs_omt &om_dest)
 
unsigned int get_seed () const
 
void set_npcs_dirty ()
 If invoked, NPCs will be reloaded before next turn. More...
 
void set_critter_died ()
 If invoked, dead will be cleaned this turn. More...
 
void mon_info (const catacurses::window &, int hor_padding=0)
 
void mon_info_update ()
 
void cleanup_dead ()
 
bool is_dangerous_tile (const tripoint &dest_loc) const
 
std::vector< std::string > get_dangerous_tile (const tripoint &dest_loc) const
 
bool prompt_dangerous_tile (const tripoint &dest_loc) const
 
void despawn_monster (monster &critter)
 Despawn a specific monster, it's stored on the overmap. More...
 
void win ()
 Marks the game as won. More...
 
bool disable_robot (const tripoint &p)
 If there is a robot (that can be disabled), query the player and try to disable it. More...
 
void draw_pixel_minimap (const catacurses::window &w)
 
void quicksave ()
 
void disp_NPCs ()
 
void list_missions ()
 
event_busevents ()
 
stats_trackerstats ()
 
memorial_loggermemorial ()
 
spell_eventsspell_events_subscriber ()
 
void display_toggle_overlay (action_id)
 
bool display_overlay_state (action_id)
 
void toggle_debug_hour_timer ()
 
tripoint mouse_edge_scrolling_terrain (input_context &ctxt)
 Used to implement mouse "edge scrolling". More...
 
tripoint mouse_edge_scrolling_overmap (input_context &ctxt)
 This variant is suitable for the overmap. More...
 
void shift_destination_preview (const point &delta)
 
bool slip_down ()
 Checks if player is able to successfully climb to/from some terrain and not slip down. More...
 
monsterplace_critter_at (const mtype_id &id, const tripoint &p)
 Adds critters to the reality bubble, creating them if necessary. More...
 
monsterplace_critter_at (const shared_ptr_fast< monster > &mon, const tripoint &p)
 
monsterplace_critter_around (const mtype_id &id, const tripoint &center, int radius)
 
monsterplace_critter_around (const shared_ptr_fast< monster > &mon, const tripoint &center, int radius, bool forced=false)
 
monsterplace_critter_within (const mtype_id &id, const tripoint_range< tripoint > &range)
 
monsterplace_critter_within (const shared_ptr_fast< monster > &mon, const tripoint_range< tripoint > &range)
 

Public Attributes

mapm
 
avataru
 
scent_mapscent
 
timed_event_managertimed_events
 
pimpl< Creature_trackercritter_tracker
 
pimpl< faction_managerfaction_manager_ptr
 
pimpl< drop_token_providertoken_provider_ptr
 
quit_status uquit
 Used in main.cpp to determine what type of quit is being performed. More...
 
bool new_game = false
 True if the game has just started or loaded, else false. More...
 
const scenarioscen
 
std::vector< monstercoming_to_stairs
 
int monstairz = 0
 
tripoint ter_view_p
 
catacurses::window w_terrain
 
catacurses::window w_overmap
 
catacurses::window w_omlegend
 
catacurses::window w_minimap
 
catacurses::window w_pixel_minimap
 
point driving_view_offset
 
bool debug_pathfinding = false
 
bool debug_submap_grid_overlay = false
 
Creaturedisplaying_visibility_creature
 Creature for which to display the visibility map. More...
 
int displaying_lighting_condition = 0
 Type of lighting condition overlay to display. More...
 
bool show_panel_adm = false
 
bool right_sidebar = false
 
bool fullscreen = false
 
bool was_fullscreen = false
 
bool auto_travel_mode = false
 
bool queue_screenshot = false
 
safe_mode_type safe_mode
 
int turnssincelastmon = 0
 
int mostseen = 0
 

Protected Member Functions

void load_data_from_dir (const std::string &path, const std::string &src, loading_ui &ui)
 Loads dynamic data from the given directory. More...
 

Private Types

enum class  vmenu_ret : int { CHANGE_TAB , QUIT , FIRE }
 

Private Member Functions

void unload_npcs ()
 Unloads all NPCs. More...
 
bool load (const save_t &name)
 
void load_master ()
 
bool start_game ()
 
bool save_factions_missions_npcs ()
 
void reset_npc_dispositions ()
 
void serialize_master (std::ostream &fout)
 
bool save_artifacts ()
 
bool save_maps ()
 
void init_autosave ()
 
void create_starting_npcs ()
 
vehicleplace_vehicle_nearby (const vproto_id &id, const point_abs_omt &origin, int min_distance, int max_distance, const std::vector< std::string > &omt_search_types={})
 
void list_items_monsters ()
 
game::vmenu_ret list_items (const std::vector< map_item_stack > &item_list)
 
std::vector< map_item_stackfind_nearby_items (int iRadius)
 
void reset_item_list_state (const catacurses::window &window, int height, bool bRadiusSort)
 
game::vmenu_ret list_monsters (const std::vector< Creature * > &monster_list)
 
bool grabbed_move (const tripoint &dp)
 Check for dangerous stuff at dest_loc, return false if the player decides not to step there. More...
 
bool grabbed_veh_move (const tripoint &dp)
 
bool grabbed_furn_move (const tripoint &dp)
 
void control_vehicle ()
 
void examine (const tripoint &p)
 
void examine ()
 
void pickup ()
 
void pickup (const tripoint &p)
 
void pickup_feet ()
 
void drop ()
 
void drop_in_direction ()
 
void butcher ()
 
void chat ()
 
void print_fields_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line)
 
void print_terrain_info (const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line)
 
void print_trap_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line)
 
void print_creature_info (const Creature *creature, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_vehicle_info (const vehicle *veh, int veh_part, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_visibility_info (const catacurses::window &w_look, int column, int &line, visibility_type visibility)
 
void print_items_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_graffiti_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
 
input_context get_player_input (std::string &action)
 
void replace_stair_monsters ()
 
void update_stair_monsters ()
 
void shift_monsters (const tripoint &shift)
 Shift all active monsters, the shift vector is the number of shifted submaps. More...
 
void perhaps_add_random_npc ()
 
void monmove ()
 
void overmap_npc_move ()
 
void process_voluntary_act_interrupt ()
 
void process_activity ()
 
void handle_key_blocking_activity ()
 
void open_consume_item_menu ()
 
bool handle_action ()
 
bool try_get_right_click_action (action_id &act, const tripoint &mouse_target)
 
bool try_get_left_click_action (action_id &act, const tripoint &mouse_target)
 
void item_action_menu ()
 
bool is_game_over ()
 
void death_screen ()
 
void win_screen ()
 
void draw_minimap ()
 
void autosave ()
 
void quickload ()
 
bool handle_mouseview (input_context &ctxt, std::string &action)
 
void display_faction_epilogues ()
 
void disp_NPC_epilogues ()
 
void display_scent ()
 
void display_temperature ()
 
void display_vehicle_ai ()
 
void display_visibility ()
 
void display_lighting ()
 
void display_radiation ()
 
void display_transparency ()
 
Creatureis_hostile_within (int distance)
 
void move_save_to_graveyard (const std::string &dirname)
 
bool save_player_data ()
 
std::pair< tripoint, tripointmouse_edge_scrolling (input_context &ctxt, int speed, const tripoint &last, bool iso)
 

Private Attributes

bool is_looking = false
 
std::vector< weak_ptr_fast< draw_callback_t > > draw_callbacks
 
cata::optional< action_iddisplaying_overlays
 
class game::debug_hour_timer debug_hour_timer
 
pimpl< mapmap_ptr
 
pimpl< avataru_ptr
 
pimpl< live_viewliveview_ptr
 
live_viewliveview
 
pimpl< scent_mapscent_ptr
 
pimpl< timed_event_managertimed_event_manager_ptr
 
pimpl< event_busevent_bus_ptr
 
pimpl< stats_trackerstats_tracker_ptr
 
pimpl< achievements_trackerachievements_tracker_ptr
 
pimpl< kill_trackerkill_tracker_ptr
 
pimpl< memorial_loggermemorial_logger_ptr
 
pimpl< spell_eventsspell_events_ptr
 
pimpl< distribution_grid_trackergrid_tracker_ptr
 
pimpl< weather_managerweather_manager_ptr
 
shared_ptr_fast< playeru_shared_ptr
 
catacurses::window w_terrain_ptr
 
catacurses::window w_minimap_ptr
 
std::string sFilter
 
std::string list_item_upvote
 
std::string list_item_downvote
 
bool safe_mode_warning_logged = false
 
bool bVMonsterLookFire = false
 
character_id next_npc_id
 
std::list< shared_ptr_fast< npc > > active_npc
 
int next_mission_id = 0
 
std::set< character_idfollower_ids
 
int moves_since_last_save = 0
 
time_t last_save_timestamp
 
std::array< float, OVERMAP_LAYERSlatest_lightlevels
 
time_point remoteveh_cache_time
 
vehicleremoteveh_cache
 
bool npcs_dirty = false
 Has a NPC been spawned since last load? More...
 
bool critter_died = false
 Has anything died in this turn and needs to be cleaned up? More...
 
bool first_redraw_since_waiting_started = true
 Is this the first redraw since waiting (sleeping or activity) started. More...
 
bool zones_manager_open = false
 Is Zone manager open or not - changes graphics of some zone tiles. More...
 
std::unique_ptr< special_gamegamemode
 
int user_action_counter = 0
 
int tileset_zoom = 0
 How far the tileset should be zoomed out, 16 is default. More...
 
unsigned int seed = 0
 Seed for all the random numbers that should have consistent randomness (weather). More...
 
std::vector< tripointdestination_preview
 
std::chrono::time_point< std::chrono::steady_clock > last_mouse_edge_scroll
 
tripoint last_mouse_edge_scroll_vector_terrain
 
tripoint last_mouse_edge_scroll_vector_overmap
 
weak_ptr_fast< ui_adaptormain_ui_adaptor
 
std::unique_ptr< static_popupwait_popup
 

Friends

class editmap
 
class advanced_inventory
 
class main_menu
 
class monster_range
 
class Creature_range
 
distribution_grid_trackerget_distribution_grid_tracker ()
 Returns distribution grid tracker that is a part of the global game *g. More...
 
mapget_map ()
 
Characterget_player_character ()
 
avatarget_avatar ()
 
weather_managerget_weather ()
 

Detailed Description

Definition at line 143 of file game.h.

Member Enumeration Documentation

◆ vmenu_ret

enum class game::vmenu_ret : int
strongprivate
Enumerator
CHANGE_TAB 
QUIT 
FIRE 

Definition at line 795 of file game.h.

795 : int {
796 CHANGE_TAB,
797 QUIT,
798 FIRE, // Who knew, apparently you can do that in list_monsters
799 };

Constructor & Destructor Documentation

◆ game()

game::game ( )

Definition at line 290 of file game.cpp.

290 :
292 scent_ptr( *this ),
295 m( *map_ptr ),
296 u( *u_ptr ),
297 scent( *scent_ptr ),
299 uquit( QUIT_NO ),
300 new_game( false ),
302 mostseen( 0 ),
305 next_npc_id( 1 ),
306 next_mission_id( 1 ),
310 seed( 0 ),
311 last_mouse_edge_scroll( std::chrono::steady_clock::now() )
312{
320 world_generator = std::make_unique<worldfactory>();
321 // do nothing, everything that was in here is moved to init_data() which is called immediately after g = new game; in main.cpp
322 // The reason for this move is so that g is not uninitialized when it gets to installing the parts into vehicles.
323}
void subscribe(event_subscriber *)
Definition: event_bus.cpp:39
int mostseen
Definition: game.h:1049
pimpl< spell_events > spell_events_ptr
Definition: game.h:984
safe_mode_type safe_mode
Definition: game.h:1046
bool safe_mode_warning_logged
Definition: game.h:1060
pimpl< timed_event_manager > timed_event_manager_ptr
Definition: game.h:978
std::chrono::time_point< std::chrono::steady_clock > last_mouse_edge_scroll
Definition: game.h:1094
quit_status uquit
Used in main.cpp to determine what type of quit is being performed.
Definition: game.h:1004
event_bus & events()
Definition: game.cpp:2873
pimpl< stats_tracker > stats_tracker_ptr
Definition: game.h:980
character_id next_npc_id
Definition: game.h:1062
pimpl< kill_tracker > kill_tracker_ptr
Definition: game.h:982
void reset_light_level()
Definition: game.cpp:3717
pimpl< memorial_logger > memorial_logger_ptr
Definition: game.h:983
shared_ptr_fast< player > u_shared_ptr
Definition: game.h:1051
pimpl< map > map_ptr
Definition: game.h:973
bool first_redraw_since_waiting_started
Is this the first redraw since waiting (sleeping or activity) started.
Definition: game.h:1077
pimpl< live_view > liveview_ptr
Definition: game.h:975
pimpl< achievements_tracker > achievements_tracker_ptr
Definition: game.h:981
pimpl< scent_map > scent_ptr
Definition: game.h:977
timed_event_manager & timed_events
Definition: game.h:992
unsigned int seed
Seed for all the random numbers that should have consistent randomness (weather).
Definition: game.h:1089
int next_mission_id
Definition: game.h:1064
bool new_game
True if the game has just started or loaded, else false.
Definition: game.h:1006
pimpl< distribution_grid_tracker > grid_tracker_ptr
Definition: game.h:985
map & m
Definition: game.h:989
avatar & u
Definition: game.h:990
scent_map & scent
Definition: game.h:991
int user_action_counter
Definition: game.h:1083
live_view & liveview
Definition: game.h:976
int tileset_zoom
How far the tileset should be zoomed out, 16 is default.
Definition: game.h:1086
pimpl< avatar > u_ptr
Definition: game.h:974
time_point remoteveh_cache_time
Definition: game.h:1070
static void achievement_attained(const achievement *a)
Definition: game.cpp:283
static constexpr int DEFAULT_TILESET_ZOOM
Definition: game.h:41
@ SAFE_MODE_ON
Definition: game.h:78
@ QUIT_NO
Definition: game.h:68
mapbuffer MAPBUFFER
Definition: mapbuffer.cpp:40
const time_point before_time_starts
A time point that is always before the current turn, even when the game has just started.
Definition: calendar.cpp:25
For use with smart pointers when you don't actually want the deleter to do anything.
Definition: cata_utility.h:28
std::unique_ptr< worldfactory > world_generator

References achievements_tracker_ptr, events(), first_redraw_since_waiting_started, kill_tracker_ptr, memorial_logger_ptr, reset_light_level(), spell_events_ptr, stats_tracker_ptr, event_bus::subscribe(), and world_generator.

◆ ~game()

game::~game ( )
default

Member Function Documentation

◆ add_artifact_dreams()

void game::add_artifact_dreams ( )

Definition at line 11927 of file game.cpp.

11928{
11929 //If player is sleeping, get a dream from a carried artifact
11930 //Don't need to check that player is sleeping here, that's done before calling
11931 std::list<item *> art_items = g->u.get_artifact_items();
11932 std::vector<item *> valid_arts;
11933 std::vector<std::vector<std::string>>
11934 valid_dreams; // Tracking separately so we only need to check its req once
11935 //Pull the list of dreams
11936 add_msg( m_debug, "Checking %s carried artifacts", art_items.size() );
11937 for( auto &it : art_items ) {
11938 //Pick only the ones with an applicable dream
11939 const cata::value_ptr<islot_artifact> &art = it->type->artifact;
11940 if( art && art->charge_req != ACR_NULL &&
11941 ( it->ammo_remaining() < it->ammo_capacity() ||
11942 it->ammo_capacity() == 0 ) ) { //or max 0 in case of wacky mod shenanigans
11943 add_msg( m_debug, "Checking artifact %s", it->tname() );
11944 if( check_art_charge_req( *it ) ) {
11945 add_msg( m_debug, " Has freq %s,%s", art->dream_freq_met, art->dream_freq_unmet );
11946 if( art->dream_freq_met > 0 && x_in_y( art->dream_freq_met, 100 ) ) {
11947 add_msg( m_debug, "Adding met dream from %s", it->tname() );
11948 valid_arts.push_back( it );
11949 valid_dreams.push_back( art->dream_msg_met );
11950 }
11951 } else {
11952 add_msg( m_debug, " Has freq %s,%s", art->dream_freq_met, art->dream_freq_unmet );
11953 if( art->dream_freq_unmet > 0 && x_in_y( art->dream_freq_unmet, 100 ) ) {
11954 add_msg( m_debug, "Adding unmet dream from %s", it->tname() );
11955 valid_arts.push_back( it );
11956 valid_dreams.push_back( art->dream_msg_unmet );
11957 }
11958 }
11959 }
11960 }
11961 if( !valid_dreams.empty() ) {
11962 add_msg( m_debug, "Found %s valid artifact dreams", valid_dreams.size() );
11963 const int selected = rng( 0, valid_arts.size() - 1 );
11964 auto it = valid_arts[selected];
11965 auto msg = random_entry( valid_dreams[selected] );
11966 const std::string &dream = string_format( _( msg ), it->tname() );
11967 add_msg( dream );
11968 } else {
11969 add_msg( m_debug, "Didn't have any dreams, sorry" );
11970 }
11971}
units::quantity< V, B > rng(const units::quantity< V, B > &min, const units::quantity< V, B > &max)
Definition: artifact.cpp:32
@ ACR_NULL
Definition: artifact.h:79
bool x_in_y(const time_duration &a, const time_duration &b)
Definition: calendar.cpp:521
This class is essentially a copyable unique pointer.
Definition: value_ptr.h:19
@ m_debug
Definition: enums.h:271
std::unique_ptr< game > g
Definition: game.cpp:273
bool check_art_charge_req(item &it)
Definition: game.cpp:11630
void add_msg(std::string msg)
Definition: messages.cpp:884
V random_entry(const C &container, D default_value)
Returns a random entry in the container.
Definition: rng.h:88
std::string string_format(std::string format, Args &&...args)
Simple wrapper over string_formatter::parse.
#define _(msg)
Definition: translations.h:116

References _, ACR_NULL, add_msg(), check_art_charge_req(), g, m_debug, random_entry(), rng(), string_format(), and x_in_y().

Referenced by do_turn().

◆ add_artifact_messages()

void game::add_artifact_messages ( const std::vector< art_effect_passive > &  effects)

Definition at line 11749 of file game.cpp.

11750{
11751 int net_str = 0;
11752 int net_dex = 0;
11753 int net_per = 0;
11754 int net_int = 0;
11755 int net_speed = 0;
11756
11757 for( auto &i : effects ) {
11758 switch( i ) {
11759 case AEP_STR_UP:
11760 net_str += 4;
11761 break;
11762 case AEP_DEX_UP:
11763 net_dex += 4;
11764 break;
11765 case AEP_PER_UP:
11766 net_per += 4;
11767 break;
11768 case AEP_INT_UP:
11769 net_int += 4;
11770 break;
11771 case AEP_ALL_UP:
11772 net_str += 2;
11773 net_dex += 2;
11774 net_per += 2;
11775 net_int += 2;
11776 break;
11777 case AEP_STR_DOWN:
11778 net_str -= 3;
11779 break;
11780 case AEP_DEX_DOWN:
11781 net_dex -= 3;
11782 break;
11783 case AEP_PER_DOWN:
11784 net_per -= 3;
11785 break;
11786 case AEP_INT_DOWN:
11787 net_int -= 3;
11788 break;
11789 case AEP_ALL_DOWN:
11790 net_str -= 2;
11791 net_dex -= 2;
11792 net_per -= 2;
11793 net_int -= 2;
11794 break;
11795
11796 case AEP_SPEED_UP:
11797 net_speed += 20;
11798 break;
11799 case AEP_SPEED_DOWN:
11800 net_speed -= 20;
11801 break;
11802
11803 case AEP_PBLUE:
11804 break; // No message
11805
11806 case AEP_SNAKES:
11807 add_msg( m_warning, _( "Your skin feels slithery." ) );
11808 break;
11809
11810 case AEP_INVISIBLE:
11811 add_msg( m_good, _( "You fade into invisibility!" ) );
11812 break;
11813
11814 case AEP_CLAIRVOYANCE:
11816 add_msg( m_good, _( "You can see through walls!" ) );
11817 break;
11818
11820 add_msg( m_good, _( "You can see through everything!" ) );
11821 break;
11822
11823 case AEP_STEALTH:
11824 add_msg( m_good, _( "Your steps stop making noise." ) );
11825 break;
11826
11827 case AEP_GLOW:
11828 add_msg( _( "A glow of light forms around you." ) );
11829 break;
11830
11831 case AEP_PSYSHIELD:
11832 add_msg( m_good, _( "Your mental state feels protected." ) );
11833 break;
11834
11836 add_msg( m_good, _( "You feel insulated." ) );
11837 break;
11838
11839 case AEP_CARRY_MORE:
11840 add_msg( m_good, _( "Your back feels strengthened." ) );
11841 break;
11842
11843 case AEP_FUN:
11844 add_msg( m_good, _( "You feel a pleasant tingle." ) );
11845 break;
11846
11847 case AEP_HUNGER:
11848 add_msg( m_warning, _( "You feel hungry." ) );
11849 break;
11850
11851 case AEP_THIRST:
11852 add_msg( m_warning, _( "You feel thirsty." ) );
11853 break;
11854
11855 case AEP_EVIL:
11856 add_msg( m_warning, _( "You feel an evil presence…" ) );
11857 break;
11858
11859 case AEP_SCHIZO:
11860 add_msg( m_bad, _( "You feel a tickle of insanity." ) );
11861 break;
11862
11863 case AEP_RADIOACTIVE:
11864 add_msg( m_warning, _( "Your skin prickles with radiation." ) );
11865 break;
11866
11867 case AEP_MUTAGENIC:
11868 add_msg( m_bad, _( "You feel your genetic makeup degrading." ) );
11869 break;
11870
11871 case AEP_ATTENTION:
11872 add_msg( m_warning, _( "You feel an otherworldly attention upon you…" ) );
11873 break;
11874
11875 case AEP_FORCE_TELEPORT:
11876 add_msg( m_bad, _( "You feel a force pulling you inwards." ) );
11877 break;
11878
11879 case AEP_MOVEMENT_NOISE:
11880 add_msg( m_warning, _( "You hear a rattling noise coming from inside yourself." ) );
11881 break;
11882
11883 case AEP_BAD_WEATHER:
11884 add_msg( m_warning, _( "You feel storms coming." ) );
11885 break;
11886
11887 case AEP_SICK:
11888 add_msg( m_bad, _( "You feel unwell." ) );
11889 break;
11890
11891 case AEP_SMOKE:
11892 add_msg( m_warning, _( "A cloud of smoke appears." ) );
11893 break;
11894 default:
11895 //Suppress warnings
11896 break;
11897 }
11898 }
11899
11900 std::string stat_info;
11901 if( net_str != 0 ) {
11902 stat_info += string_format( _( "Str %s%d! " ),
11903 ( net_str > 0 ? "+" : "" ), net_str );
11904 }
11905 if( net_dex != 0 ) {
11906 stat_info += string_format( _( "Dex %s%d! " ),
11907 ( net_dex > 0 ? "+" : "" ), net_dex );
11908 }
11909 if( net_int != 0 ) {
11910 stat_info += string_format( _( "Int %s%d! " ),
11911 ( net_int > 0 ? "+" : "" ), net_int );
11912 }
11913 if( net_per != 0 ) {
11914 stat_info += string_format( _( "Per %s%d! " ),
11915 ( net_per > 0 ? "+" : "" ), net_per );
11916 }
11917
11918 if( !stat_info.empty() ) {
11919 add_msg( m_neutral, stat_info );
11920 }
11921
11922 if( net_speed != 0 ) {
11923 add_msg( m_info, _( "Speed %s%d!" ), ( net_speed > 0 ? "+" : "" ), net_speed );
11924 }
11925}
@ m_good
Definition: enums.h:260
@ m_neutral
Definition: enums.h:267
@ m_info
Definition: enums.h:265
@ m_bad
Definition: enums.h:261
@ m_warning
Definition: enums.h:264
@ AEP_GLOW
Definition: enums.h:115
@ AEP_MUTAGENIC
Definition: enums.h:130
@ AEP_ALL_UP
Definition: enums.h:106
@ AEP_INT_UP
Definition: enums.h:105
@ AEP_INT_DOWN
Definition: enums.h:135
@ AEP_PER_UP
Definition: enums.h:104
@ AEP_PSYSHIELD
Definition: enums.h:116
@ AEP_CLAIRVOYANCE_PLUS
Definition: enums.h:142
@ AEP_MOVEMENT_NOISE
Definition: enums.h:139
@ AEP_STEALTH
Definition: enums.h:113
@ AEP_CARRY_MORE
Definition: enums.h:118
@ AEP_THIRST
Definition: enums.h:125
@ AEP_SPEED_UP
Definition: enums.h:107
@ AEP_EVIL
Definition: enums.h:127
@ AEP_ALL_DOWN
Definition: enums.h:136
@ AEP_DEX_UP
Definition: enums.h:103
@ AEP_SCHIZO
Definition: enums.h:128
@ AEP_DEX_DOWN
Definition: enums.h:133
@ AEP_FUN
Definition: enums.h:120
@ AEP_PER_DOWN
Definition: enums.h:134
@ AEP_FORCE_TELEPORT
Definition: enums.h:138
@ AEP_ATTENTION
Definition: enums.h:131
@ AEP_RADIOACTIVE
Definition: enums.h:129
@ AEP_SUPER_CLAIRVOYANCE
Definition: enums.h:112
@ AEP_BAD_WEATHER
Definition: enums.h:140
@ AEP_SICK
Definition: enums.h:141
@ AEP_CLAIRVOYANCE
Definition: enums.h:111
@ AEP_INVISIBLE
Definition: enums.h:110
@ AEP_STR_UP
Definition: enums.h:102
@ AEP_STR_DOWN
Definition: enums.h:132
@ AEP_HUNGER
Definition: enums.h:124
@ AEP_RESIST_ELECTRICITY
Definition: enums.h:117
@ AEP_PBLUE
Definition: enums.h:108
@ AEP_SPEED_DOWN
Definition: enums.h:137
@ AEP_SNAKES
Definition: enums.h:109
@ AEP_SMOKE
Definition: enums.h:126

References _, add_msg(), AEP_ALL_DOWN, AEP_ALL_UP, AEP_ATTENTION, AEP_BAD_WEATHER, AEP_CARRY_MORE, AEP_CLAIRVOYANCE, AEP_CLAIRVOYANCE_PLUS, AEP_DEX_DOWN, AEP_DEX_UP, AEP_EVIL, AEP_FORCE_TELEPORT, AEP_FUN, AEP_GLOW, AEP_HUNGER, AEP_INT_DOWN, AEP_INT_UP, AEP_INVISIBLE, AEP_MOVEMENT_NOISE, AEP_MUTAGENIC, AEP_PBLUE, AEP_PER_DOWN, AEP_PER_UP, AEP_PSYSHIELD, AEP_RADIOACTIVE, AEP_RESIST_ELECTRICITY, AEP_SCHIZO, AEP_SICK, AEP_SMOKE, AEP_SNAKES, AEP_SPEED_DOWN, AEP_SPEED_UP, AEP_STEALTH, AEP_STR_DOWN, AEP_STR_UP, AEP_SUPER_CLAIRVOYANCE, AEP_THIRST, m_bad, m_good, m_info, m_neutral, m_warning, and string_format().

◆ add_draw_callback()

void game::add_draw_callback ( shared_ptr_fast< draw_callback_t cb)

Definition at line 3168 of file game.cpp.

3169{
3170 draw_callbacks.erase(
3171 std::remove_if( draw_callbacks.begin(), draw_callbacks.end(),
3172 []( const weak_ptr_fast<draw_callback_t> &cbw ) {
3173 return cbw.expired();
3174 } ),
3175 draw_callbacks.end()
3176 );
3177 draw_callbacks.emplace_back( cb );
3178 cb->added = true;
3180}
void invalidate_main_ui_adaptor() const
Definition: game.cpp:3133
std::vector< weak_ptr_fast< draw_callback_t > > draw_callbacks
Definition: game.h:251
std::weak_ptr< T > weak_ptr_fast
Definition: memory_fast.h:17

References draw_callbacks, and invalidate_main_ui_adaptor().

Referenced by get_player_input(), list_items(), list_monsters(), look_around(), pickup(), and zones_manager().

◆ add_npc_follower()

void game::add_npc_follower ( const character_id id)

Add follower id to set of followers.

Definition at line 1983 of file game.cpp.

1984{
1985 follower_ids.insert( id );
1986 u.follower_ids.insert( id );
1987}
std::set< character_id > follower_ids
Definition: game.h:1065
std::set< character_id > follower_ids
Definition: player.h:617

References follower_ids, player::follower_ids, and u.

Referenced by validate_npc_followers().

◆ all_creatures()

game::Creature_range game::all_creatures ( )

Returns an anonymous range that contains all creatures.

The range allows iteration via a range-based for loop, e.g. for( Creature &critter : all_creatures() ) { ... }. One shall not store the returned range nor the iterators. One can freely remove and add creatures to the game during the iteration. Added creatures will not be iterated over.

Definition at line 12083 of file game.cpp.

12084{
12085 return Creature_range( *this );
12086}
friend class Creature_range
Definition: game.h:360

References Creature_range.

Referenced by draw_ter(), get_creature_if(), and get_creatures_if().

◆ all_monsters()

game::monster_range game::all_monsters ( )

Same as all_creatures but iterators only over monsters.

Definition at line 12088 of file game.cpp.

12089{
12090 return monster_range( *this );
12091}
friend class monster_range
Definition: game.h:359

References monster_range.

Referenced by cleanup_at_end(), disp_NPCs(), get_fishable_monsters(), monmove(), place_player_overmap(), shift_monsters(), start_game(), validate_mounted_npcs(), and vertical_move().

◆ all_npcs()

game::npc_range game::all_npcs ( )

Same as all_creatures but iterators only over npcs.

Definition at line 12093 of file game.cpp.

12094{
12095 return npc_range( *this );
12096}

Referenced by do_turn(), and get_npcs_if().

◆ allies()

std::vector< npc * > game::allies ( )

Get all living player allies.

Definition at line 11997 of file game.cpp.

11998{
11999 return get_npcs_if( [&]( const npc & guy ) {
12000 if( !guy.is_hallucination() ) {
12001 return guy.is_ally( g->u );
12002 } else {
12003 return false;
12004 }
12005 } );
12006}
std::vector< npc * > get_npcs_if(const std::function< bool(const npc &)> &pred)
Definition: game.cpp:12020
Definition: npc.h:781
bool is_hallucination() const override
Definition: npc.cpp:3260

References get_npcs_if(), and npc::is_hallucination().

◆ assign_mission_id()

int game::assign_mission_id ( )

Returns the next available mission id.

Definition at line 1971 of file game.cpp.

1972{
1973 int ret = next_mission_id;
1975 return ret;
1976}

References next_mission_id, and cata::hash64_detail::ret.

◆ assign_npc_id()

character_id game::assign_npc_id ( )

Definition at line 3725 of file game.cpp.

3726{
3728 ++next_npc_id;
3729 return ret;
3730}

References next_npc_id, and cata::hash64_detail::ret.

Referenced by load(), and start_game().

◆ autopilot_vehicles()

void game::autopilot_vehicles ( )

process vehicles that are following the player

Definition at line 1770 of file game.cpp.

1771{
1772 for( wrapped_vehicle &veh : m.get_vehicles() ) {
1773 vehicle *&v = veh.v;
1774 if( v->is_following ) {
1775 v->drive_to_local_target( m.getabs( u.pos() ), true );
1776 } else if( v->is_patrolling ) {
1777 v->autopilot_patrol();
1778 }
1779 }
1780}
const tripoint & pos() const override
Definition: character.cpp:714
tripoint getabs(const tripoint &p) const
Translates local (to this map) coordinates of a square to global absolute coordinates.
Definition: map.cpp:8261
VehicleList get_vehicles()
Definition: map.cpp:237
A vehicle as a whole with all its components.
Definition: vehicle.h:675
void autopilot_patrol()
Definition: vehicle.cpp:701
bool is_following
Definition: vehicle.h:1983
bool is_patrolling
Definition: vehicle.h:1984
void drive_to_local_target(const tripoint &target, bool follow_protocol)
Definition: vehicle.cpp:816

References vehicle::autopilot_patrol(), vehicle::drive_to_local_target(), map::get_vehicles(), map::getabs(), vehicle::is_following, vehicle::is_patrolling, m, Character::pos(), and u.

Referenced by do_turn().

◆ autosave()

void game::autosave ( )
private

Definition at line 11416 of file game.cpp.

11417{
11418 //Don't autosave if the min-autosave interval has not passed since the last autosave/quicksave.
11419 if( time( nullptr ) < last_save_timestamp + 60 * get_option<int>( "AUTOSAVE_MINUTES" ) ) {
11420 return;
11421 }
11422 quicksave(); //Driving checks are handled by quicksave()
11423}
time_t last_save_timestamp
Definition: game.h:1067
void quicksave()
Definition: game.cpp:11371

References last_save_timestamp, and quicksave().

Referenced by do_turn().

◆ butcher()

void game::butcher ( )
private

Definition at line 8411 of file game.cpp.

8412{
8413 static const std::string salvage_string = "salvage";
8414 if( u.controlling_vehicle ) {
8415 add_msg( m_info, _( "You can't butcher while driving!" ) );
8416 return;
8417 }
8418
8419 const int factor = u.max_quality( quality_id( "BUTCHER" ) );
8420 const int factorD = u.max_quality( quality_id( "CUT_FINE" ) );
8421 const std::string no_knife_msg = _( "You don't have a butchering tool." );
8422 const std::string no_corpse_msg = _( "There are no corpses here to butcher." );
8423
8424 //You can't butcher on sealed terrain- you have to smash/shovel/etc it open first
8425 if( m.has_flag( "SEALED", u.pos() ) ) {
8426 if( m.sees_some_items( u.pos(), u ) ) {
8427 add_msg( m_info, _( "You can't access the items here." ) );
8428 } else if( factor > INT_MIN || factorD > INT_MIN ) {
8429 add_msg( m_info, no_corpse_msg );
8430 } else {
8431 add_msg( m_info, no_knife_msg );
8432 }
8433 return;
8434 }
8435
8436 const item *first_item_without_tools = nullptr;
8437 // Indices of relevant items
8438 std::vector<map_stack::iterator> corpses;
8439 std::vector<map_stack::iterator> disassembles;
8440 std::vector<map_stack::iterator> salvageables;
8441 map_stack items = m.i_at( u.pos() );
8442 const inventory &crafting_inv = u.crafting_inventory();
8443
8444 // TODO: Properly handle different material whitelists
8445 // TODO: Improve quality of this section
8446 auto salvage_filter = []( item it ) {
8447 const auto usable = it.get_usable_item( salvage_string );
8448 return usable != nullptr;
8449 };
8450
8451 std::vector< item * > salvage_tools = u.items_with( salvage_filter );
8452 int salvage_tool_index = INT_MIN;
8453 item *salvage_tool = nullptr;
8454 const salvage_actor *salvage_iuse = nullptr;
8455 if( !salvage_tools.empty() ) {
8456 salvage_tool = salvage_tools.front();
8457 salvage_tool_index = u.get_item_position( salvage_tool );
8458 item *usable = salvage_tool->get_usable_item( salvage_string );
8459 salvage_iuse = dynamic_cast<const salvage_actor *>(
8460 usable->get_use( salvage_string )->get_actor_ptr() );
8461 }
8462
8463 // Reserve capacity for each to hold entire item set if necessary to prevent
8464 // reallocations later on
8465 corpses.reserve( items.size() );
8466 salvageables.reserve( items.size() );
8467 disassembles.reserve( items.size() );
8468
8469 // Split into corpses, disassemble-able, and salvageable items
8470 // It's not much additional work to just generate a corpse list and
8471 // clear it later, but does make the splitting process nicer.
8472 for( map_stack::iterator it = items.begin(); it != items.end(); ++it ) {
8473 if( it->is_corpse() ) {
8474 corpses.push_back( it );
8475 } else {
8476 if( ( salvage_tool_index != INT_MIN ) && salvage_iuse->valid_to_cut_up( *it ) ) {
8477 salvageables.push_back( it );
8478 }
8479 if( crafting::can_disassemble( u, *it, crafting_inv ).success() ) {
8480 disassembles.push_back( it );
8481 } else if( !first_item_without_tools ) {
8482 first_item_without_tools = &*it;
8483 }
8484 }
8485 }
8486
8487 // Clear corpses if butcher and dissect factors are INT_MIN
8488 if( factor == INT_MIN && factorD == INT_MIN ) {
8489 corpses.clear();
8490 }
8491
8492 if( corpses.empty() && disassembles.empty() && salvageables.empty() ) {
8493 if( factor > INT_MIN || factorD > INT_MIN ) {
8494 add_msg( m_info, no_corpse_msg );
8495 } else {
8496 add_msg( m_info, no_knife_msg );
8497 }
8498
8499 if( first_item_without_tools ) {
8500 add_msg( m_info, _( "You don't have the necessary tools to disassemble any items here." ) );
8501 // Just for the "You need x to disassemble y" messages
8502 const auto ret = crafting::can_disassemble( u, *first_item_without_tools, crafting_inv );
8503 if( !ret.success() ) {
8504 add_msg( m_info, "%s", ret.c_str() );
8505 }
8506 }
8507 return;
8508 }
8509
8510 Creature *hostile_critter = is_hostile_very_close();
8511 if( hostile_critter != nullptr ) {
8512 if( !query_yn( _( "You see %s nearby! Start butchering anyway?" ),
8513 hostile_critter->disp_name() ) ) {
8514 return;
8515 }
8516 }
8517
8518 // Magic indices for special butcher options
8519 enum : int {
8520 MULTISALVAGE = MAX_ITEM_IN_SQUARE + 1,
8521 MULTIBUTCHER,
8522 MULTIDISASSEMBLE_ONE,
8523 MULTIDISASSEMBLE_ALL,
8524 NUM_BUTCHER_ACTIONS
8525 };
8526 // What are we butchering (i.e.. which vector to pick indices from)
8527 enum {
8528 BUTCHER_CORPSE,
8529 BUTCHER_DISASSEMBLE,
8530 BUTCHER_SALVAGE,
8531 BUTCHER_OTHER // For multisalvage etc.
8532 } butcher_select = BUTCHER_CORPSE;
8533 // Index to std::vector of iterators...
8534 int indexer_index = 0;
8535
8536 // Generate the indexed stacks so we can display them nicely
8537 const auto disassembly_stacks = generate_butcher_stack_display( disassembles );
8538 const auto salvage_stacks = generate_butcher_stack_display( salvageables );
8539 // Always ask before cutting up/disassembly, but not before butchery
8540 size_t ret = 0;
8541 if( !corpses.empty() || !disassembles.empty() || !salvageables.empty() ) {
8542 uilist kmenu;
8543 kmenu.text = _( "Choose corpse to butcher / item to disassemble" );
8544
8545 size_t i = 0;
8546 // Add corpses, disassembleables, and salvagables to the UI
8547 add_corpses( kmenu, corpses, i );
8548 add_disassemblables( kmenu, disassembly_stacks, i );
8549 if( salvage_iuse && !salvageables.empty() ) {
8550 add_salvagables( kmenu, salvage_stacks, i, *salvage_iuse );
8551 }
8552
8553 if( corpses.size() > 1 ) {
8554 kmenu.addentry( MULTIBUTCHER, true, 'b', _( "Butcher everything" ) );
8555 }
8556 if( disassembles.size() > 1 ) {
8557 int time_to_disassemble = 0;
8558 int time_to_disassemble_all = 0;
8559 for( const auto &stack : disassembly_stacks ) {
8560 const int time = recipe_dictionary::get_uncraft( stack.first->typeId() ).time;
8561 time_to_disassemble += time;
8562 time_to_disassemble_all += time * stack.second;
8563 }
8564
8565 kmenu.addentry_col( MULTIDISASSEMBLE_ONE, true, 'D', _( "Disassemble everything once" ),
8566 to_string_clipped( time_duration::from_turns( time_to_disassemble / 100 ) ) );
8567 kmenu.addentry_col( MULTIDISASSEMBLE_ALL, true, 'd', _( "Disassemble everything recursively" ),
8568 to_string_clipped( time_duration::from_turns( time_to_disassemble_all / 100 ) ) );
8569 }
8570 if( salvage_iuse && salvageables.size() > 1 ) {
8571 int time_to_salvage = 0;
8572 for( const auto &stack : salvage_stacks ) {
8573 time_to_salvage += salvage_iuse->time_to_cut_up( *stack.first ) * stack.second;
8574 }
8575
8576 kmenu.addentry_col( MULTISALVAGE, true, 'z', _( "Cut up everything" ),
8577 to_string_clipped( time_duration::from_turns( time_to_salvage / 100 ) ) );
8578 }
8579
8580 kmenu.query();
8581
8582 if( kmenu.ret < 0 || kmenu.ret >= NUM_BUTCHER_ACTIONS ) {
8583 return;
8584 }
8585
8586 ret = static_cast<size_t>( kmenu.ret );
8587 if( ret >= MULTISALVAGE && ret < NUM_BUTCHER_ACTIONS ) {
8588 butcher_select = BUTCHER_OTHER;
8589 indexer_index = ret;
8590 } else if( ret < corpses.size() ) {
8591 butcher_select = BUTCHER_CORPSE;
8592 indexer_index = ret;
8593 } else if( ret < corpses.size() + disassembly_stacks.size() ) {
8594 butcher_select = BUTCHER_DISASSEMBLE;
8595 indexer_index = ret - corpses.size();
8596 } else if( ret < corpses.size() + disassembly_stacks.size() + salvage_stacks.size() ) {
8597 butcher_select = BUTCHER_SALVAGE;
8598 indexer_index = ret - corpses.size() - disassembly_stacks.size();
8599 } else {
8600 debugmsg( "Invalid butchery index: %d", ret );
8601 return;
8602 }
8603 }
8604
8605 if( !u.has_morale_to_craft() ) {
8606 if( butcher_select == BUTCHER_CORPSE || indexer_index == MULTIBUTCHER ) {
8607 add_msg( m_info,
8608 _( "You are not in the mood and the prospect of guts and blood on your hands convinces you to turn away." ) );
8609 } else {
8610 add_msg( m_info,
8611 _( "You are not in the mood and the prospect of work stops you before you begin." ) );
8612 }
8613 return;
8614 }
8615 const auto helpers = u.get_crafting_helpers( 3 );
8616 for( const npc *np : helpers ) {
8617 add_msg( m_info, _( "%s helps with this task…" ), np->name );
8618 }
8619 switch( butcher_select ) {
8620 case BUTCHER_OTHER:
8621 switch( indexer_index ) {
8622 case MULTISALVAGE:
8623 u.assign_activity( activity_id( "ACT_LONGSALVAGE" ), 0, salvage_tool_index );
8624 break;
8625 case MULTIBUTCHER:
8626 butcher_submenu( corpses );
8627 for( map_stack::iterator &it : corpses ) {
8628 u.activity.targets.emplace_back( map_cursor( u.pos() ), &*it );
8629 }
8630 break;
8631 case MULTIDISASSEMBLE_ONE:
8632 crafting::disassemble_all( u, false );
8633 break;
8634 case MULTIDISASSEMBLE_ALL:
8636 break;
8637 default:
8638 debugmsg( "Invalid butchery type: %d", indexer_index );
8639 return;
8640 }
8641 break;
8642 case BUTCHER_CORPSE: {
8643 butcher_submenu( corpses, indexer_index );
8644 u.activity.targets.emplace_back( map_cursor( u.pos() ), &*corpses[indexer_index] );
8645 }
8646 break;
8647 case BUTCHER_DISASSEMBLE: {
8648 // Pick index of first item in the disassembly stack
8649 item *const target = &*disassembly_stacks[indexer_index].first;
8651 }
8652 break;
8653 case BUTCHER_SALVAGE: {
8654 if( !salvage_iuse || !salvage_tool ) {
8655 debugmsg( "null salve_iuse or salvage_tool" );
8656 } else {
8657 // Pick index of first item in the salvage stack
8658 item *const target = &*salvage_stacks[indexer_index].first;
8659 item_location item_loc( map_cursor( u.pos() ), target );
8660 salvage_iuse->cut_up( u, *salvage_tool, item_loc );
8661 }
8662 }
8663 break;
8664 }
8665}
string_id< activity_type > activity_id
Definition: activity_type.h:15
static std::string to_string_clipped(const int num, const clipped_unit type, const clipped_align align)
Definition: calendar.cpp:228
bool controlling_vehicle
Definition: character.h:228
player_activity activity
Definition: character.h:1516
int get_item_position(const item *it) const
Returns the item position (suitable for i_at or similar) of a specific item.
Definition: character.cpp:2407
bool has_morale_to_craft() const
Definition: crafting.cpp:335
const inventory & crafting_inventory(bool clear_path)
Definition: crafting.cpp:553
void assign_activity(const activity_id &type, int moves=calendar::INDEFINITELY_LONG, int index=-1, int pos=INT_MIN, const std::string &name="")
Legacy activity assignment, does not work for any activites using the new activity_actor class and ma...
Definition: character.cpp:9194
virtual std::string disp_name(bool possessive=false, bool capitalize_first=false) const =0
Creature * is_hostile_very_close()
Definition: game.cpp:3739
A lightweight handle to an item independent of it's location Unlike a raw pointer can be (de-)seriali...
Definition: item_location.h:23
size_t size() const
Definition: item_stack.cpp:10
iterator begin()
Definition: item_stack.cpp:28
iterator end()
Definition: item_stack.cpp:33
Definition: item.h:177
item * get_usable_item(const std::string &use_name)
Checks this item and its contents (recursively) for types that have use_function with type use_name.
Definition: item.cpp:7833
const use_function * get_use(const std::string &use_name) const
Returns the pointer to use_function with name use_name assigned to the type of this item or any of it...
Definition: item.cpp:7807
Definition: map.h:105
bool has_flag(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2293
map_stack i_at(const tripoint &p)
Definition: map.cpp:4079
bool sees_some_items(const tripoint &p, const Creature &who) const
Check if creature can see some items at p.
Definition: map.cpp:4725
std::vector< item_location > targets
std::vector< npc * > get_crafting_helpers(size_t max=0) const
Returns nearby NPCs ready and willing to help with crafting or some other manual task.
Definition: crafting.cpp:2308
static const recipe & get_uncraft(const itype_id &id)
Returns disassembly recipe (or null recipe if no match)
int time
Definition: recipe.h:59
Cuts stuff up into components.
Definition: iuse_actor.h:567
bool valid_to_cut_up(const item &it) const
int cut_up(player &p, item &it, item_location &cut) const
int time_to_cut_up(const item &it) const
static constexpr time_duration from_turns(const T t)
Named constructors to get a duration representing a multiple of the named time units.
Definition: calendar.h:204
uilist: scrolling vertical list menu
Definition: ui.h:187
int ret
Definition: ui.h:412
void addentry_col(int r, bool e, int k, const std::string &str, const std::string &column, const std::string &desc="")
Definition: ui.cpp:962
std::string text
Definition: ui.h:320
void addentry(const std::string &str)
Definition: ui.cpp:942
int max_quality(const quality_id &qual) const
Return maximum tool quality level provided by instance or INT_MIN if not found.
Definition: visitable.cpp:276
std::vector< item * > items_with(const std::function< bool(const item &)> &filter)
Returns all items (including those within a container) matching the filter.
Definition: visitable.cpp:324
#define debugmsg(...)
Debug message of level DL::Error and class DC::DebugMsg, also includes the source file name and line,...
Definition: debug.h:74
static void butcher_submenu(const std::vector< map_stack::iterator > &corpses, int corpse=-1)
Definition: game.cpp:8261
static void add_salvagables(uilist &menu, const std::vector< std::pair< map_stack::iterator, int > > &stacks, size_t &menu_index, const salvage_actor &salvage_iuse)
Definition: game.cpp:8219
static void add_disassemblables(uilist &menu, const std::vector< std::pair< map_stack::iterator, int > > &stacks, size_t &menu_index)
Definition: game.cpp:8240
static std::vector< std::pair< map_stack::iterator, int > > generate_butcher_stack_display(const std::vector< map_stack::iterator > &its)
Definition: game.cpp:8172
static void add_corpses(uilist &menu, const std::vector< map_stack::iterator > &its, size_t &menu_index)
Definition: game.cpp:8207
static constexpr int MAX_ITEM_IN_SQUARE
void query(bool loop=true, int timeout=-1)
Handle input and update display.
Definition: ui.cpp:838
ret_val< bool > can_disassemble(const Character &who, const item &obj, const inventory &inv)
Check if character can disassemble an item using the given crafting inventory.
Definition: crafting.cpp:1875
bool disassemble(avatar &you)
Prompt for an item to disassemble, then start activity.
Definition: crafting.cpp:2074
bool disassemble_all(avatar &you, bool recursively)
Start an activity to disassemble all items in avatar's square.
Definition: crafting.cpp:2085
bool query_yn(const std::string &text)
Definition: output.cpp:698
iuse_actor * get_actor_ptr()
Definition: iuse.h:314
string_id< quality > quality_id
Definition: type_id.h:181

References _, Character::activity, add_corpses(), add_disassemblables(), add_msg(), add_salvagables(), uilist::addentry(), uilist::addentry_col(), Character::assign_activity(), item_stack::begin(), butcher_submenu(), crafting::can_disassemble(), Character::controlling_vehicle, Character::crafting_inventory(), salvage_actor::cut_up(), debugmsg, crafting::disassemble(), crafting::disassemble_all(), Creature::disp_name(), item_stack::end(), time_duration::from_turns(), generate_butcher_stack_display(), use_function::get_actor_ptr(), player::get_crafting_helpers(), Character::get_item_position(), recipe_dictionary::get_uncraft(), item::get_usable_item(), item::get_use(), map::has_flag(), Character::has_morale_to_craft(), map::i_at(), is_hostile_very_close(), visitable< T >::items_with(), m, m_info, MAX_ITEM_IN_SQUARE, visitable< T >::max_quality(), Character::pos(), uilist::query(), query_yn(), cata::hash64_detail::ret, uilist::ret, map::sees_some_items(), item_stack::size(), player_activity::targets, uilist::text, recipe::time, salvage_actor::time_to_cut_up(), to_string_clipped(), u, and salvage_actor::valid_to_cut_up().

Referenced by handle_action().

◆ calc_driving_offset()

void game::calc_driving_offset ( vehicle veh = nullptr)

Definition at line 1350 of file game.cpp.

1351{
1352 if( veh == nullptr || !get_option<bool>( "DRIVING_VIEW_OFFSET" ) ) {
1354 return;
1355 }
1356 const int g_light_level = static_cast<int>( light_level( u.posz() ) );
1357 const int light_sight_range = u.sight_range( g_light_level );
1358 int sight = std::max( veh_lumi( *veh ), light_sight_range );
1359
1360 // The maximal offset will leave at least this many tiles
1361 // between the PC and the edge of the main window.
1362 static const int border_range = 2;
1363 point max_offset( ( getmaxx( w_terrain ) + 1 ) / 2 - border_range - 1,
1364 ( getmaxy( w_terrain ) + 1 ) / 2 - border_range - 1 );
1365
1366 // velocity at or below this results in no offset at all
1367 static const float min_offset_vel = 1 * vehicles::vmiph_per_tile;
1368 // velocity at or above this results in maximal offset
1369 static const float max_offset_vel = std::min( max_offset.y, max_offset.x ) *
1371 float velocity = veh->velocity;
1372 rl_vec2d offset = veh->move_vec();
1373 if( !veh->skidding && veh->player_in_control( u ) &&
1374 std::abs( veh->cruise_velocity - veh->velocity ) < 7 * vehicles::vmiph_per_tile ) {
1375 // Use the cruise controlled velocity, but only if
1376 // it is not too different from the actual velocity.
1377 // The actual velocity changes too often (see above slowdown).
1378 // Using it makes would make the offset change far too often.
1379 offset = veh->face_vec();
1380 velocity = veh->cruise_velocity;
1381 }
1382 float rel_offset;
1383 if( std::fabs( velocity ) < min_offset_vel ) {
1384 rel_offset = 0;
1385 } else if( std::fabs( velocity ) > max_offset_vel ) {
1386 rel_offset = ( velocity > 0 ) ? 1 : -1;
1387 } else {
1388 rel_offset = ( velocity - min_offset_vel ) / ( max_offset_vel - min_offset_vel );
1389 }
1390 // Squeeze into the corners, by making the offset vector longer,
1391 // the PC is still in view as long as both offset.x and
1392 // offset.y are <= 1
1393 if( std::fabs( offset.x ) > std::fabs( offset.y ) && std::fabs( offset.x ) > 0.2 ) {
1394 offset.y /= std::fabs( offset.x );
1395 offset.x = ( offset.x > 0 ) ? +1 : -1;
1396 } else if( std::fabs( offset.y ) > 0.2 ) {
1397 offset.x /= std::fabs( offset.y );
1398 offset.y = offset.y > 0 ? +1 : -1;
1399 }
1400 offset.x *= rel_offset;
1401 offset.y *= rel_offset;
1402 offset.x *= max_offset.x;
1403 offset.y *= max_offset.y;
1404 // [ ----@---- ] sight=6
1405 // [ --@------ ] offset=2
1406 // [ -@------# ] offset=3
1407 // can see sights square in every direction, total visible area is
1408 // (2*sight+1)x(2*sight+1), but the window is only
1409 // getmaxx(w_terrain) x getmaxy(w_terrain)
1410 // The area outside of the window is maxoff (sight-getmax/2).
1411 // If that value is <= 0, the whole visible area fits the window.
1412 // don't apply the view offset at all.
1413 // If the offset is > maxoff, only apply at most maxoff, everything
1414 // above leads to invisible area in front of the car.
1415 // It will display (getmax/2+offset) squares in one direction and
1416 // (getmax/2-offset) in the opposite direction (centered on the PC).
1417 const point maxoff( ( sight * 2 + 1 - getmaxx( w_terrain ) ) / 2,
1418 ( sight * 2 + 1 - getmaxy( w_terrain ) ) / 2 );
1419 if( maxoff.x <= 0 ) {
1420 offset.x = 0;
1421 } else if( offset.x > 0 && offset.x > maxoff.x ) {
1422 offset.x = maxoff.x;
1423 } else if( offset.x < 0 && -offset.x > maxoff.x ) {
1424 offset.x = -maxoff.x;
1425 }
1426 if( maxoff.y <= 0 ) {
1427 offset.y = 0;
1428 } else if( offset.y > 0 && offset.y > maxoff.y ) {
1429 offset.y = maxoff.y;
1430 } else if( offset.y < 0 && -offset.y > maxoff.y ) {
1431 offset.y = -maxoff.y;
1432 }
1433
1434 // Turn the offset into a vector that increments the offset toward the desired position
1435 // instead of setting it there instantly, should smooth out jerkiness.
1436 const point offset_difference( -driving_view_offset + point( offset.x, offset.y ) );
1437
1438 const point offset_sign( ( offset_difference.x < 0 ) ? -1 : 1,
1439 ( offset_difference.y < 0 ) ? -1 : 1 );
1440 // Shift the current offset in the direction of the calculated offset by one tile
1441 // per draw event, but snap to calculated offset if we're close enough to avoid jitter.
1442 offset.x = ( std::abs( offset_difference.x ) > 1 ) ?
1443 ( driving_view_offset.x + offset_sign.x ) : offset.x;
1444 offset.y = ( std::abs( offset_difference.y ) > 1 ) ?
1445 ( driving_view_offset.y + offset_sign.y ) : offset.y;
1446
1447 set_driving_view_offset( point( offset.x, offset.y ) );
1448}
int posz() const override
Definition: character.h:785
int sight_range(int light_level) const override
Returns the player's sight range.
Definition: character.cpp:719
point driving_view_offset
Definition: game.h:1023
catacurses::window w_terrain
Definition: game.h:1013
void set_driving_view_offset(const point &p)
Definition: game.cpp:1707
unsigned char light_level(int zlev) const
Returns coarse number-of-squares of visibility at the current light level.
Definition: game.cpp:3711
rl_vec2d move_vec() const
rl_vec2d face_vec() const
bool skidding
Definition: vehicle.h:1999
bool player_in_control(const Character &p) const
Definition: vehicle.cpp:277
int velocity
Definition: vehicle.h:1918
int cruise_velocity
Definition: vehicle.h:1920
static int veh_lumi(vehicle &veh)
Definition: game.cpp:1332
int getmaxx(const window &win)
Definition: ncurses_def.cpp:58
int getmaxy(const window &win)
Definition: ncurses_def.cpp:63
quantity< V, U > fabs(quantity< V, U > q)
Definition: units_def.h:136
constexpr float vmiph_per_tile
Definition: vehicle.h:68
static constexpr point point_zero
Definition: point.h:274
Definition: point.h:35
int y
Definition: point.h:39
int x
Definition: point.h:38
float y
Definition: point_float.h:13
float x
Definition: point_float.h:12

References vehicle::cruise_velocity, driving_view_offset, units::fabs(), vehicle::face_vec(), catacurses::getmaxx(), catacurses::getmaxy(), light_level(), vehicle::move_vec(), vehicle::player_in_control(), point_zero, Character::posz(), set_driving_view_offset(), Character::sight_range(), vehicle::skidding, u, veh_lumi(), vehicle::velocity, vehicles::vmiph_per_tile, w_terrain, point::x, rl_vec2d::x, point::y, and rl_vec2d::y.

Referenced by do_turn().

◆ cancel_activity_or_ignore_query()

bool game::cancel_activity_or_ignore_query ( distraction_type  type,
const std::string &  text 
)

Asks if the player wants to cancel their activity and if so cancels it.

Additionally checks if the player wants to ignore further distractions.

Definition at line 1809 of file game.cpp.

1810{
1812 if( u.has_distant_destination() ) {
1813 if( cancel_auto_move( u, text ) ) {
1814 return true;
1815 } else {
1817 return false;
1818 }
1819 }
1821 return false;
1822 }
1823 const bool force_uc = get_option<bool>( "FORCE_CAPITAL_YN" );
1824 const auto &allow_key = force_uc ? input_context::disallow_lower_case
1826
1827 const auto &action = query_popup()
1828 .context( "CANCEL_ACTIVITY_OR_IGNORE_QUERY" )
1829 .message( force_uc ?
1830 pgettext( "cancel_activity_or_ignore_query",
1831 "<color_light_red>%s %s (Case Sensitive)</color>" ) :
1832 pgettext( "cancel_activity_or_ignore_query",
1833 "<color_light_red>%s %s</color>" ),
1834 text, u.activity.get_stop_phrase() )
1835 .option( "YES", allow_key )
1836 .option( "NO", allow_key )
1837 .option( "MANAGER", allow_key )
1838 .option( "IGNORE", allow_key )
1839 .query()
1840 .action;
1841
1842 if( action == "YES" ) {
1844 return true;
1845 }
1846 if( action == "IGNORE" ) {
1848 for( auto &activity : u.backlog ) {
1849 activity.ignore_distraction( type );
1850 }
1851 }
1852 if( action == "MANAGER" ) {
1855 return true;
1856 }
1857
1860
1861 return false;
1862}
void set_destination(const std::vector< tripoint > &route, const player_activity &new_destination_activity=player_activity())
void cancel_activity()
Definition: character.cpp:9237
std::vector< tripoint > & get_auto_move_route()
std::list< player_activity > backlog
Definition: character.h:1517
bool has_distant_destination() const
static const input_event_filter allow_all_keys
Definition: input.h:545
static const input_event_filter disallow_lower_case
Definition: input.h:544
bool is_distraction_ignored(distraction_type type) const
std::string get_stop_phrase() const
void ignore_distraction(distraction_type type)
UI class for displaying messages or querying player input with popups.
Definition: popup.h:39
query_popup & context(const std::string &cat)
Specify the input context.
Definition: popup.cpp:21
query_popup & option(const std::string &opt)
Specify an action as an option.
Definition: popup.cpp:28
result query()
Query until a valid action or an error happens and return the result.
Definition: popup.cpp:348
query_popup & message(const std::string &fmt, Args &&... args)
Specify the query message.
Definition: popup.h:91
@ action
Definition: dialogue.h:36
distraction_manager::distraction_manager_gui & get_distraction_manager()
@ type
Definition: enums.h:75
static bool cancel_auto_move(player &p, const std::string &text)
Definition: game.cpp:1796
void redraw()
Invalidate the top window and redraw all invalidated windows.
Definition: ui_manager.cpp:389
void refresh_display()
Make changes made to the display visible to the user immediately.
std::string action
Definition: popup.h:68
const char * pgettext(const char *context, const char *msgid)

References action, query_popup::result::action, Character::activity, input_context::allow_all_keys, Character::backlog, Character::cancel_activity(), cancel_auto_move(), query_popup::context(), input_context::disallow_lower_case, Character::get_auto_move_route(), get_distraction_manager(), player_activity::get_stop_phrase(), Character::has_distant_destination(), player_activity::ignore_distraction(), invalidate_main_ui_adaptor(), player_activity::is_distraction_ignored(), query_popup::message(), query_popup::option(), pgettext(), query_popup::query(), ui_manager::redraw(), refresh_display(), Character::set_destination(), distraction_manager::distraction_manager_gui::show(), type, and u.

Referenced by mon_info_update(), monmove(), and process_voluntary_act_interrupt().

◆ cancel_activity_query()

bool game::cancel_activity_query ( const std::string &  text)

Asks if the player wants to cancel their activity, and if so cancels it.

Definition at line 1864 of file game.cpp.

1865{
1867 if( u.has_distant_destination() ) {
1868 if( cancel_auto_move( u, text ) ) {
1869 return true;
1870 } else {
1872 return false;
1873 }
1874 }
1875 if( !u.activity ) {
1876 return false;
1877 }
1878 if( query_yn( "%s %s", text, u.activity.get_stop_phrase() ) ) {
1882 return true;
1883 }
1884 return false;
1885}
void clear_destination()
void resume_backlog_activity()
Definition: character.cpp:9269

References Character::activity, Character::cancel_activity(), cancel_auto_move(), Character::clear_destination(), Character::get_auto_move_route(), player_activity::get_stop_phrase(), Character::has_distant_destination(), invalidate_main_ui_adaptor(), query_yn(), Character::resume_backlog_activity(), Character::set_destination(), and u.

Referenced by handle_key_blocking_activity().

◆ catch_a_monster()

void game::catch_a_monster ( monster fish,
const tripoint pos,
player p,
const time_duration catch_duration 
)

Picks and spawns a random fish from the remaining fish list when a fish is caught.

Definition at line 1782 of file game.cpp.

1784{
1785 //spawn the corpse, rotten by a part of the duration
1787 catch_duration ) ) );
1788 if( u.sees( pos ) ) {
1789 u.add_msg_if_player( m_good, _( "You caught a %s." ), fish->type->nname() );
1790 }
1791 //quietly kill the caught
1792 fish->no_corpse_quiet = true;
1793 fish->die( p );
1794}
bool sees(const tripoint &t, bool is_player=false, int range_mod=0) const override
static item make_corpse(const mtype_id &mt=string_id< mtype >::NULL_ID(), time_point turn=calendar::turn, const std::string &name="", int upgrade_time=-1)
Make a corpse of the given monster type.
Definition: item.cpp:507
item & add_item_or_charges(const tripoint &pos, item obj, bool overflow=true)
Adds an item to map tile or stacks charges.
Definition: map.cpp:4224
bool no_corpse_quiet
Definition: monster.h:485
void die(Creature *killer) override
Empty function.
Definition: monster.cpp:2268
const mtype * type
Definition: monster.h:481
void add_msg_if_player(const std::string &msg) const override
Definition: player.cpp:3973
time_point turn
Definition: calendar.cpp:36
mtype_id id
Definition: mtype.h:240
std::string nname(unsigned int quantity=1) const
Definition: mtype.cpp:65

References _, map::add_item_or_charges(), player::add_msg_if_player(), monster::die(), mtype::id, m, m_good, item::make_corpse(), mtype::nname(), monster::no_corpse_quiet, rng(), Character::sees(), calendar::turn, monster::type, and u.

◆ chat()

void game::chat ( )
private

Definition at line 394 of file npctalk.cpp.

395{
396 int volume = g->u.get_shout_volume();
397
398 const std::vector<npc *> available = get_npcs_if( [&]( const npc & guy ) {
399 // TODO: Get rid of the z-level check when z-level vision gets "better"
400 return u.posz() == guy.posz() && u.sees( guy.pos() ) &&
401 rl_dist( u.pos(), guy.pos() ) <= SEEX * 2;
402 } );
403 const int available_count = available.size();
404 const std::vector<npc *> followers = get_npcs_if( [&]( const npc & guy ) {
405 return guy.is_player_ally() && guy.is_following() && guy.can_hear( u.pos(), volume );
406 } );
407 const int follower_count = followers.size();
408 const std::vector<npc *> guards = get_npcs_if( [&]( const npc & guy ) {
409 return guy.mission == NPC_MISSION_GUARD_ALLY &&
410 guy.companion_mission_role_id != "FACTION_CAMP" &&
411 guy.can_hear( u.pos(), volume );
412 } );
413 const int guard_count = guards.size();
414
415 if( g->u.has_trait( trait_PROF_FOODP ) && !( g->u.is_wearing( itype_id( "foodperson_mask" ) ) ||
416 g->u.is_wearing( itype_id( "foodperson_mask_on" ) ) ) ) {
417 g->u.add_msg_if_player( m_warning, _( "You can't speak without your face!" ) );
418 return;
419 }
420 std::vector<vehicle *> animal_vehicles;
421 std::vector<vehicle *> following_vehicles;
422 std::vector<vehicle *> magic_vehicles;
423 std::vector<vehicle *> magic_following_vehicles;
424 for( auto &veh : g->m.get_vehicles() ) {
425 auto &v = veh.v;
426 if( v->has_engine_type( fuel_type_animal, false ) && v->is_owned_by( g->u ) ) {
427 animal_vehicles.push_back( v );
428 if( v->is_following ) {
429 following_vehicles.push_back( v );
430 }
431 }
432 if( v->magic ) {
433 for( const vpart_reference &vp : v->get_all_parts() ) {
434 const vpart_info &vpi = vp.info();
435 if( vpi.has_flag( "MAGIC_FOLLOW" ) ) {
436 magic_vehicles.push_back( v );
437 if( v->is_following ) {
438 magic_following_vehicles.push_back( v );
439 }
440 break;
441 }
442 }
443 }
444 }
445
446 uilist nmenu;
447 nmenu.text = std::string( _( "What do you want to do?" ) );
448
449 if( !available.empty() ) {
450 nmenu.addentry( NPC_CHAT_TALK, true, 't', available_count == 1 ?
451 string_format( _( "Talk to %s" ), available.front()->name ) :
452 _( "Talk to…" )
453 );
454 }
455 nmenu.addentry( NPC_CHAT_YELL, true, 'a', _( "Yell" ) );
456 nmenu.addentry( NPC_CHAT_SENTENCE, true, 'b', _( "Yell a sentence" ) );
457 if( !animal_vehicles.empty() ) {
459 _( "Whistle at your animals pulling vehicles to follow you." ) );
460 }
461 if( !magic_vehicles.empty() ) {
463 _( "Utter a magical command that will order your magical vehicles to follow you." ) );
464 }
465 if( !magic_following_vehicles.empty() ) {
467 _( "Utter a magical command that will order your magical vehicles to stop following you." ) );
468 }
469 if( !following_vehicles.empty() ) {
471 _( "Whistle at your animals pulling vehicles to stop following you." ) );
472 }
473 if( !guards.empty() ) {
474 nmenu.addentry( NPC_CHAT_FOLLOW, true, 'f', guard_count == 1 ?
475 string_format( _( "Tell %s to follow" ), guards.front()->name ) :
476 _( "Tell someone to follow…" )
477 );
478 }
479 if( !followers.empty() ) {
480 nmenu.addentry( NPC_CHAT_GUARD, true, 'g', follower_count == 1 ?
481 string_format( _( "Tell %s to guard" ), followers.front()->name ) :
482 _( "Tell someone to guard…" )
483 );
484 nmenu.addentry( NPC_CHAT_AWAKE, true, 'w', _( "Tell everyone on your team to wake up" ) );
485 nmenu.addentry( NPC_CHAT_MOUNT, true, 'M', _( "Tell everyone on your team to mount up" ) );
486 nmenu.addentry( NPC_CHAT_DISMOUNT, true, 'm', _( "Tell everyone on your team to dismount" ) );
487 nmenu.addentry( NPC_CHAT_DANGER, true, 'D',
488 _( "Tell everyone on your team to prepare for danger" ) );
489 nmenu.addentry( NPC_CHAT_CLEAR_OVERRIDES, true, 'r',
490 _( "Tell everyone on your team to relax (Clear Overrides)" ) );
491 nmenu.addentry( NPC_CHAT_ORDERS, true, 'o', _( "Tell everyone on your team to temporarily…" ) );
492 }
493 std::string message;
494 std::string yell_msg;
495 bool is_order = true;
496 nmenu.query();
497
498 if( nmenu.ret < 0 ) {
499 return;
500 }
501
502 switch( nmenu.ret ) {
503 case NPC_CHAT_TALK: {
504 const int npcselect = npc_select_menu( available, _( "Talk to whom?" ), false );
505 if( npcselect < 0 ) {
506 return;
507 }
508 available[npcselect]->talk_to_u();
509 break;
510 }
511 case NPC_CHAT_YELL:
512 is_order = false;
513 message = _( "loudly." );
514 break;
515 case NPC_CHAT_SENTENCE: {
516 std::string popupdesc = _( "Enter a sentence to yell" );
518 popup.title( _( "Yell a sentence" ) )
519 .width( 64 )
520 .description( popupdesc )
521 .identifier( "sentence" )
522 .max_length( 128 )
523 .query();
524 yell_msg = popup.text();
525 is_order = false;
526 break;
527 }
528 case NPC_CHAT_GUARD: {
529 const int npcselect = npc_select_menu( followers, _( "Who should guard here?" ) );
530 if( npcselect < 0 ) {
531 return;
532 }
533 if( npcselect == follower_count ) {
534 for( npc *them : followers ) {
536 }
537 yell_msg = _( "Everyone guard here!" );
538 } else {
539 talk_function::assign_guard( *followers[npcselect] );
540 yell_msg = string_format( _( "Guard here, %s!" ), followers[npcselect]->name );
541 }
542 break;
543 }
544 case NPC_CHAT_FOLLOW: {
545 const int npcselect = npc_select_menu( guards, _( "Who should follow you?" ) );
546 if( npcselect < 0 ) {
547 return;
548 }
549 if( npcselect == guard_count ) {
550 for( npc *them : guards ) {
552 }
553 yell_msg = _( "Everyone follow me!" );
554 } else {
555 talk_function::stop_guard( *guards[npcselect] );
556 yell_msg = string_format( _( "Follow me, %s!" ), guards[npcselect]->name );
557 }
558 break;
559 }
560 case NPC_CHAT_AWAKE:
561 for( npc *them : followers ) {
562 talk_function::wake_up( *them );
563 }
564 yell_msg = _( "Stay awake!" );
565 break;
566 case NPC_CHAT_MOUNT:
567 for( npc *them : followers ) {
568 if( them->has_effect( effect_riding ) ) {
569 continue;
570 }
572 }
573 yell_msg = _( "Mount up!" );
574 break;
576 for( npc *them : followers ) {
577 if( them->has_effect( effect_riding ) ) {
578 them->npc_dismount();
579 }
580 }
581 yell_msg = _( "Dismount!" );
582 break;
583 case NPC_CHAT_DANGER:
584 for( npc *them : followers ) {
585 them->rules.set_danger_overrides();
586 }
587 yell_msg = _( "We're in danger. Stay awake, stay close, don't go wandering off, "
588 "and don't open any doors." );
589 break;
591 for( npc *p : followers ) {
593 }
594 yell_msg = _( "As you were." );
595 break;
596 case NPC_CHAT_ORDERS:
597 npc_temp_orders_menu( followers );
598 break;
601 break;
604 break;
607 break;
610 break;
611 default:
612 return;
613 }
614
615 if( !yell_msg.empty() ) {
616 message = string_format( "\"%s\"", yell_msg );
617 }
618 if( !message.empty() ) {
619 add_msg( _( "You yell %s" ), message );
620 u.shout( string_format( _( "%s yelling %s" ), u.disp_name(), message ), is_order );
621 }
622
623 u.moves -= 100;
624}
std::string disp_name(bool possessive=false, bool capitalize_first=false) const override
Returns either "you" or the player's name.
Definition: character.cpp:546
void shout(std::string msg="", bool order=false)
Definition: character.cpp:7729
bool can_hear(const tripoint &source, int volume) const
int moves
Definition: creature.h:569
std::string companion_mission_role_id
Definition: npc.h:1318
npc_mission mission
Definition: npc.h:1325
bool is_player_ally() const
Definition: npc.cpp:1987
bool is_following() const
Definition: npc.cpp:2018
Shows a window querying the user for input.
bool has_flag(const std::string &flag) const
Definition: veh_type.h:336
This is a wrapper over a vehicle pointer and a reference to a part of it.
int rl_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:519
static constexpr int SEEX
std::string message
Definition: mapgen.cpp:407
std::string name(type dir)
Get Human readable name of a direction.
Definition: overmap.cpp:4126
void wake_up(npc &)
void find_mount(npc &)
void clear_overrides(npc &p)
void stop_guard(npc &)
void assign_guard(npc &)
quantity< int, volume_in_milliliter_tag > volume
Definition: units_volume.h:16
@ NPC_MISSION_GUARD_ALLY
Definition: npc.h:187
static const efftype_id effect_riding("riding")
static const trait_id trait_PROF_FOODP("PROF_FOODP")
static int npc_select_menu(const std::vector< npc * > &npc_list, const std::string &prompt, const bool everyone=true)
Definition: npctalk.cpp:220
static void tell_magic_veh_stop_following()
Definition: npctalk.cpp:377
static void tell_veh_stop_following()
Definition: npctalk.cpp:340
static void assign_veh_to_follow()
Definition: npctalk.cpp:351
static void npc_temp_orders_menu(const std::vector< npc * > &npc_list)
Definition: npctalk.cpp:252
static const itype_id fuel_type_animal("animal")
@ NPC_CHAT_MOUNT
Definition: npctalk.cpp:200
@ NPC_CHAT_COMMAND_MAGIC_VEHICLE_STOP_FOLLOW
Definition: npctalk.cpp:214
@ NPC_CHAT_YELL
Definition: npctalk.cpp:195
@ NPC_CHAT_FOLLOW
Definition: npctalk.cpp:198
@ NPC_CHAT_GUARD
Definition: npctalk.cpp:197
@ NPC_CHAT_DISMOUNT
Definition: npctalk.cpp:201
@ NPC_CHAT_ANIMAL_VEHICLE_FOLLOW
Definition: npctalk.cpp:211
@ NPC_CHAT_ORDERS
Definition: npctalk.cpp:203
@ NPC_CHAT_SENTENCE
Definition: npctalk.cpp:196
@ NPC_CHAT_CLEAR_OVERRIDES
Definition: npctalk.cpp:210
@ NPC_CHAT_DANGER
Definition: npctalk.cpp:202
@ NPC_CHAT_AWAKE
Definition: npctalk.cpp:199
@ NPC_CHAT_ANIMAL_VEHICLE_STOP_FOLLOW
Definition: npctalk.cpp:212
@ NPC_CHAT_TALK
Definition: npctalk.cpp:194
@ NPC_CHAT_COMMAND_MAGIC_VEHICLE_FOLLOW
Definition: npctalk.cpp:213
static void tell_magic_veh_to_follow()
Definition: npctalk.cpp:361
int popup(const std::string &text, PopupFlags flags)
Definition: output.cpp:764

References _, add_msg(), uilist::addentry(), talk_function::assign_guard(), assign_veh_to_follow(), available, Character::can_hear(), talk_function::clear_overrides(), npc::companion_mission_role_id, Character::disp_name(), effect_riding, talk_function::find_mount(), fuel_type_animal, g, get_npcs_if(), vpart_info::has_flag(), npc::is_following(), npc::is_player_ally(), m_warning, mapgen_defer::message, npc::mission, Creature::moves, om_direction::name(), NPC_CHAT_ANIMAL_VEHICLE_FOLLOW, NPC_CHAT_ANIMAL_VEHICLE_STOP_FOLLOW, NPC_CHAT_AWAKE, NPC_CHAT_CLEAR_OVERRIDES, NPC_CHAT_COMMAND_MAGIC_VEHICLE_FOLLOW, NPC_CHAT_COMMAND_MAGIC_VEHICLE_STOP_FOLLOW, NPC_CHAT_DANGER, NPC_CHAT_DISMOUNT, NPC_CHAT_FOLLOW, NPC_CHAT_GUARD, NPC_CHAT_MOUNT, NPC_CHAT_ORDERS, NPC_CHAT_SENTENCE, NPC_CHAT_TALK, NPC_CHAT_YELL, NPC_MISSION_GUARD_ALLY, npc_select_menu(), npc_temp_orders_menu(), popup(), Character::pos(), Character::posz(), uilist::query(), uilist::ret, rl_dist(), Character::sees(), SEEX, Character::shout(), talk_function::stop_guard(), string_format(), tell_magic_veh_stop_following(), tell_magic_veh_to_follow(), tell_veh_stop_following(), uilist::text, trait_PROF_FOODP, u, and talk_function::wake_up().

Referenced by handle_action().

◆ check_mod_data()

bool game::check_mod_data ( const std::vector< mod_id > &  opts,
loading_ui ui 
)

Check if mods can be successfully loaded.

Parameters
optscheck specific mods (or all if unspecified)
Returns
whether all mods were successfully loaded

Definition at line 350 of file game.cpp.

351{
352 auto &tree = world_generator->get_mod_manager().get_tree();
353
354 // deduplicated list of mods to check
355 std::set<mod_id> check( opts.begin(), opts.end() );
356
357 // if no specific mods specified check all non-obsolete mods
358 if( check.empty() ) {
359 for( const mod_id &e : world_generator->get_mod_manager().all_mods() ) {
360 if( !e->obsolete ) {
361 check.emplace( e );
362 }
363 }
364 }
365
366 if( check.empty() ) {
367 world_generator->set_active_world( nullptr );
368 world_generator->init();
369 const std::vector<mod_id> mods_empty;
370 WORLDPTR test_world = world_generator->make_new_world( mods_empty );
371 world_generator->set_active_world( test_world );
372
373 // if no loadable mods then test core data only
374 try {
377 } catch( const std::exception &err ) {
378 std::cerr << "Error loading data from json: " << err.what() << std::endl;
379 }
380
381 std::string world_name = world_generator->active_world->world_name;
382 world_generator->delete_world( world_name, true );
383
386 }
387
388 for( const auto &e : check ) {
389 world_generator->set_active_world( nullptr );
390 world_generator->init();
391 const std::vector<mod_id> mods_empty;
392 WORLDPTR test_world = world_generator->make_new_world( mods_empty );
393 if( !test_world ) {
394 std::cerr << "Failed to generate test world." << std::endl;
395 return false;
396 }
397 world_generator->set_active_world( test_world );
398
399 if( !e.is_valid() ) {
400 std::cerr << "Unknown mod: " << e.str() << std::endl;
401 return false;
402 }
403
404 const MOD_INFORMATION &mod = *e;
405
406 if( !tree.is_available( mod.ident ) ) {
407 std::cerr << "Missing dependencies: " << mod.name() << "\n"
408 << tree.get_node( mod.ident )->s_errors() << std::endl;
409 return false;
410 }
411
412 std::cout << "Checking mod " << mod.name() << " [" << mod.ident.str() << "]" << std::endl;
413
414 try {
416
417 // Load any dependencies
418 for( auto &dep : tree.get_dependencies_of_X_as_strings( mod.ident ) ) {
419 load_data_from_dir( dep->path, dep->ident.str(), ui );
420 }
421
422 // Load mod itself
423 load_data_from_dir( mod.path, mod.ident.str(), ui );
425 } catch( const std::exception &err ) {
426 std::cerr << "Error loading data: " << err.what() << std::endl;
427 }
428
429 std::string world_name = world_generator->active_world->world_name;
430 world_generator->delete_world( world_name, true );
431
434 }
435 return true;
436}
void finalize_loaded_data(loading_ui &ui)
Called to finalize the loaded data.
Definition: init.cpp:636
static DynamicDataLoader & get_instance()
Returns the single instance of this class.
Definition: init.cpp:114
void load_data_from_dir(const std::string &path, const std::string &src, loading_ui &ui)
Loads dynamic data from the given directory.
Definition: game.cpp:452
void load_core_data(loading_ui &ui)
Loads core dynamic data.
Definition: game.cpp:443
void reset()
Delete all buffered submaps.
Definition: mapbuffer.cpp:49
int check(unformattable)
Definition: fmtlib_core.h:1610
Definition: overmap_ui.h:17
overmapbuffer overmap_buffer

References detail::check(), overmapbuffer::clear(), DynamicDataLoader::finalize_loaded_data(), DynamicDataLoader::get_instance(), load_core_data(), load_data_from_dir(), MAPBUFFER, overmap_buffer, mapbuffer::reset(), and world_generator.

◆ check_near_zone()

bool game::check_near_zone ( const zone_type_id type,
const tripoint where 
) const

Checks whether or not there is a zone of particular type nearby.

Definition at line 6133 of file game.cpp.

6134{
6135 return zone_manager::get_manager().has_near( type, m.getabs( where ) );
6136}
static zone_manager & get_manager()
Definition: clzones.cpp:126
bool has_near(const zone_type_id &type, const tripoint &where, int range=MAX_DISTANCE, const faction_id &fac=your_fac) const
Definition: clzones.cpp:702

References zone_manager::get_manager(), map::getabs(), zone_manager::has_near(), m, and type.

◆ check_safe_mode_allowed()

bool game::check_safe_mode_allowed ( bool  repeat_safe_mode_warnings = true)

Check whether movement is allowed according to safe mode settings.

Returns
true if the movement is allowed, otherwise false.

Definition at line 8667 of file game.cpp.

8668{
8669 if( !repeat_safe_mode_warnings && safe_mode_warning_logged ) {
8670 // Already warned player since safe_mode_warning_logged is set.
8671 return false;
8672 }
8673
8674 std::string msg_ignore = press_x( ACTION_IGNORE_ENEMY );
8675 if( !msg_ignore.empty() ) {
8676 std::wstring msg_ignore_wide = utf8_to_wstr( msg_ignore );
8677 // Operate on a wide-char basis to prevent corrupted multi-byte string
8678 msg_ignore_wide[0] = towlower( msg_ignore_wide[0] );
8679 msg_ignore = wstr_to_utf8( msg_ignore_wide );
8680 }
8681
8683 // Automatic and mandatory safemode. Make BLOODY sure the player notices!
8684 if( u.get_int_base() < 5 || u.has_trait( trait_id( "PROF_CHURL" ) ) ) {
8686 _( "There's an angry red dot on your body, %s to brush it off." ), msg_ignore );
8687 } else {
8689 _( "You are being laser-targeted, %s to ignore." ), msg_ignore );
8690 }
8692 return false;
8693 }
8694 if( safe_mode != SAFE_MODE_STOP ) {
8695 return true;
8696 }
8697 // Currently driving around, ignore the monster, they have no chance against a proper car anyway (-:
8698 if( u.controlling_vehicle && !get_option<bool>( "SAFEMODEVEH" ) ) {
8699 return true;
8700 }
8701 // Monsters around and we don't want to run
8702 std::string spotted_creature_name;
8703 const monster_visible_info &mon_visible = u.get_mon_visible();
8704 const auto &new_seen_mon = mon_visible.new_seen_mon;
8705
8706 if( new_seen_mon.empty() ) {
8707 // naming consistent with code in game::mon_info
8708 spotted_creature_name = _( "a survivor" );
8710 } else {
8711 spotted_creature_name = new_seen_mon.back()->name();
8712 get_safemode().lastmon_whitelist = spotted_creature_name;
8713 }
8714
8715 std::string whitelist;
8716 if( !get_safemode().empty() ) {
8717 whitelist = string_format( _( " or %s to whitelist the monster" ),
8719 }
8720
8721 const std::string msg_safe_mode = press_x( ACTION_TOGGLE_SAFEMODE );
8723 _( "Spotted %1$s--safe mode is on! (%2$s to turn it off, %3$s to ignore monster%4$s)" ),
8724 spotted_creature_name, msg_safe_mode, msg_ignore, whitelist );
8726 return false;
8727}
std::string press_x(action_id act)
Definition: action.cpp:455
@ ACTION_IGNORE_ENEMY
Ignore the enemy that triggered safemode.
Definition: action.h:221
@ ACTION_WHITELIST_ENEMY
Whitelist the enemy that triggered safemode.
Definition: action.h:223
@ ACTION_TOGGLE_SAFEMODE
Turn safemode on/off, while leaving autosafemode intact.
Definition: action.h:215
std::wstring utf8_to_wstr(const std::string &str)
std::string wstr_to_utf8(const std::wstring &wstr)
bool has_trait(const trait_id &b) const override
Returns true if the player has the entered trait.
Definition: mutation.cpp:103
bool has_effect(const efftype_id &eff_id, body_part bp=num_bp) const
Check if creature has the matching effect.
Definition: creature.cpp:1179
int get_int_base() const override
Definition: avatar.cpp:1006
monster_visible_info & get_mon_visible()
Definition: avatar.h:213
std::string lastmon_whitelist
Definition: safemode_ui.h:87
std::string npc_type_name()
Definition: safemode_ui.cpp:44
@ gmf_bypass_cooldown
Definition: enums.h:288
static const efftype_id effect_laserlocked("laserlocked")
@ SAFE_MODE_STOP
Definition: game.h:79
safemode & get_safemode()
Definition: safemode_ui.cpp:33
Structure allowing a combination of game_message_type and game_message_flags.
Definition: enums.h:293
std::vector< shared_ptr_fast< monster > > new_seen_mon
Definition: avatar.h:40

References _, ACTION_IGNORE_ENEMY, ACTION_TOGGLE_SAFEMODE, ACTION_WHITELIST_ENEMY, add_msg(), Character::controlling_vehicle, effect_laserlocked, avatar::get_int_base(), avatar::get_mon_visible(), get_safemode(), gmf_bypass_cooldown, Creature::has_effect(), Character::has_trait(), safemode::lastmon_whitelist, m_warning, monster_visible_info::new_seen_mon, safemode::npc_type_name(), press_x(), safe_mode, SAFE_MODE_STOP, safe_mode_warning_logged, string_format(), u, utf8_to_wstr(), and wstr_to_utf8().

Referenced by handle_action().

◆ check_zone()

bool game::check_zone ( const zone_type_id type,
const tripoint where 
) const

Definition at line 6128 of file game.cpp.

6129{
6130 return zone_manager::get_manager().has( type, m.getabs( where ) );
6131}
bool has(const zone_type_id &type, const tripoint &where, const faction_id &fac=your_fac) const
Definition: clzones.cpp:694

References zone_manager::get_manager(), map::getabs(), zone_manager::has(), m, and type.

Referenced by place_player().

◆ cleanup_at_end()

bool game::cleanup_at_end ( )

Definition at line 1046 of file game.cpp.

1047{
1048 if( uquit == QUIT_DIED || uquit == QUIT_SUICIDE ) {
1049 // Put (non-hallucinations) into the overmap so they are not lost.
1050 for( monster &critter : all_monsters() ) {
1051 despawn_monster( critter );
1052 }
1053 // Reset NPC factions and disposition
1055 // Save the factions', missions and set the NPC's overmap coordinates
1056 // Npcs are saved in the overmap.
1057 save_factions_missions_npcs(); //missions need to be saved as they are global for all saves.
1058 // save artifacts.
1060
1061 // and the overmap, and the local map.
1062 save_maps(); //Omap also contains the npcs who need to be saved.
1063 }
1064
1065 if( uquit == QUIT_DIED || uquit == QUIT_SUICIDE ) {
1066 std::vector<std::string> vRip;
1067
1068 int iMaxWidth = 0;
1069 int iNameLine = 0;
1070 int iInfoLine = 0;
1071
1074 if( !( u.has_trait( trait_id( "CANNIBAL" ) ) || u.has_trait( trait_id( "PSYCHOPATH" ) ) ) ) {
1075 vRip.emplace_back( " _______ ___" );
1076 vRip.emplace_back( " < `/ |" );
1077 vRip.emplace_back( " > _ _ (" );
1078 vRip.emplace_back( " | |_) | |_) |" );
1079 vRip.emplace_back( " | | \\ | | |" );
1080 vRip.emplace_back( " ______.__%_| |_________ __" );
1081 vRip.emplace_back( " _/ \\| |" );
1082 iNameLine = vRip.size();
1083 vRip.emplace_back( "| <" );
1084 vRip.emplace_back( "| |" );
1085 iMaxWidth = utf8_width( vRip.back() );
1086 vRip.emplace_back( "| |" );
1087 vRip.emplace_back( "|_____.-._____ __/|_________|" );
1088 vRip.emplace_back( " | |" );
1089 iInfoLine = vRip.size();
1090 vRip.emplace_back( " | |" );
1091 vRip.emplace_back( " | <" );
1092 vRip.emplace_back( " | |" );
1093 vRip.emplace_back( " | _ |" );
1094 vRip.emplace_back( " |__/ |" );
1095 vRip.emplace_back( " % / `--. |%" );
1096 vRip.emplace_back( " * .%%| -< @%%%" ); // NOLINT(cata-text-style)
1097 vRip.emplace_back( " `\\%`@| |@@%@%%" );
1098 vRip.emplace_back( " .%%%@@@|% ` % @@@%%@%%%%" );
1099 vRip.emplace_back( " _.%%%%%%@@@@@@%%%__/\\%@@%%@@@@@@@%%%%%%" );
1100
1101 } else {
1102 vRip.emplace_back( " _______ ___" );
1103 vRip.emplace_back( " | \\/ |" );
1104 vRip.emplace_back( " | |" );
1105 vRip.emplace_back( " | |" );
1106 iInfoLine = vRip.size();
1107 vRip.emplace_back( " | |" );
1108 vRip.emplace_back( " | |" );
1109 vRip.emplace_back( " | |" );
1110 vRip.emplace_back( " | |" );
1111 vRip.emplace_back( " | <" );
1112 vRip.emplace_back( " | _ |" );
1113 vRip.emplace_back( " |__/ |" );
1114 vRip.emplace_back( " ______.__%_| |__________ _" );
1115 vRip.emplace_back( " _/ \\| \\" );
1116 iNameLine = vRip.size();
1117 vRip.emplace_back( "| <" );
1118 vRip.emplace_back( "| |" );
1119 iMaxWidth = utf8_width( vRip.back() );
1120 vRip.emplace_back( "| |" );
1121 vRip.emplace_back( "|_____.-._______ __/|__________|" );
1122 vRip.emplace_back( " % / `_-. _ |%" );
1123 vRip.emplace_back( " * .%%| |_) | |_)< @%%%" ); // NOLINT(cata-text-style)
1124 vRip.emplace_back( " `\\%`@| | \\ | | |@@%@%%" );
1125 vRip.emplace_back( " .%%%@@@|% ` % @@@%%@%%%%" );
1126 vRip.emplace_back( " _.%%%%%%@@@@@@%%%__/\\%@@%%@@@@@@@%%%%%%" );
1127 }
1128 } else {
1129 vRip.emplace_back( R"( _________ ____ )" );
1130 vRip.emplace_back( R"( _/ `/ \_ )" );
1131 vRip.emplace_back( R"( _/ _ _ \_. )" );
1132 vRip.emplace_back( R"( _%\ |_) | |_) \_ )" );
1133 vRip.emplace_back( R"( _/ \/ | \ | | \_ )" );
1134 vRip.emplace_back( R"( _/ \_ )" );
1135 vRip.emplace_back( R"(| |)" );
1136 iNameLine = vRip.size();
1137 vRip.emplace_back( R"( ) < )" );
1138 vRip.emplace_back( R"(| |)" );
1139 vRip.emplace_back( R"(| |)" );
1140 vRip.emplace_back( R"(| _ |)" );
1141 vRip.emplace_back( R"(|__/ |)" );
1142 iMaxWidth = utf8_width( vRip.back() );
1143 vRip.emplace_back( R"( / `--. |)" );
1144 vRip.emplace_back( R"(| ( )" );
1145 iInfoLine = vRip.size();
1146 vRip.emplace_back( R"(| |)" );
1147 vRip.emplace_back( R"(| |)" );
1148 vRip.emplace_back( R"(| % . |)" );
1149 vRip.emplace_back( R"(| @` %% |)" );
1150 vRip.emplace_back( R"(| %@%@%\ * %`%@%|)" );
1151 vRip.emplace_back( R"(%%@@@.%@%\%% `\ %%.%%@@%@)" );
1152 vRip.emplace_back( R"(@%@@%%%%%@@@@@@%%%%%%%%@@%%@@@%%%@%%@)" );
1153 }
1154
1155 const int iOffsetX = TERMX > FULL_SCREEN_WIDTH ? ( TERMX - FULL_SCREEN_WIDTH ) / 2 : 0;
1156 const int iOffsetY = TERMY > FULL_SCREEN_HEIGHT ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0;
1157
1159 point( iOffsetX, iOffsetY ) );
1160 draw_border( w_rip );
1161
1162 sfx::do_player_death_hurt( g->u, true );
1167
1168 for( size_t iY = 0; iY < vRip.size(); ++iY ) {
1169 size_t iX = 0;
1170 const char *str = vRip[iY].data();
1171 for( int slen = vRip[iY].size(); slen > 0; ) {
1172 const uint32_t cTemp = UTF8_getch( &str, &slen );
1173 if( cTemp != U' ' ) {
1174 nc_color ncColor = c_light_gray;
1175
1176 if( cTemp == U'%' ) {
1177 ncColor = c_green;
1178
1179 } else if( cTemp == U'_' || cTemp == U'|' ) {
1180 ncColor = c_white;
1181
1182 } else if( cTemp == U'@' ) {
1183 ncColor = c_brown;
1184
1185 } else if( cTemp == U'*' ) {
1186 ncColor = c_red;
1187 }
1188
1189 mvwputch( w_rip, point( iX + FULL_SCREEN_WIDTH / 2 - ( iMaxWidth / 2 ), iY + 1 ), ncColor,
1190 cTemp );
1191 }
1192 iX += mk_wcwidth( cTemp );
1193 }
1194 }
1195
1196 std::string sTemp;
1197
1198 center_print( w_rip, iInfoLine++, c_white, _( "Survived:" ) );
1199
1201 const int minutes = to_minutes<int>( survived ) % 60;
1202 const int hours = to_hours<int>( survived ) % 24;
1203 const int days = to_days<int>( survived );
1204
1205 if( days > 0 ) {
1206 sTemp = string_format( "%dd %dh %dm", days, hours, minutes );
1207 } else if( hours > 0 ) {
1208 sTemp = string_format( "%dh %dm", hours, minutes );
1209 } else {
1210 sTemp = string_format( "%dm", minutes );
1211 }
1212
1213 center_print( w_rip, iInfoLine++, c_white, sTemp );
1214
1215 const int iTotalKills = get_kill_tracker().monster_kill_count();
1216
1217 sTemp = _( "Kills:" );
1218 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - 5, 1 + iInfoLine++ ), c_light_gray,
1219 ( sTemp + " " ) );
1220 wprintz( w_rip, c_magenta, "%d", iTotalKills );
1221
1222 sTemp = _( "In memory of:" );
1223 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ),
1225 sTemp );
1226
1227 sTemp = u.name;
1228 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ), c_white,
1229 sTemp );
1230
1231 sTemp = _( "Last Words:" );
1232 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ),
1234 sTemp );
1235
1236 int iStartX = FULL_SCREEN_WIDTH / 2 - ( ( iMaxWidth - 4 ) / 2 );
1237 std::string sLastWords = string_input_popup()
1238 .window( w_rip, point( iStartX, iNameLine ), iStartX + iMaxWidth - 4 - 1 )
1239 .max_length( iMaxWidth - 4 - 1 )
1240 .query_string();
1241 death_screen();
1242 const bool is_suicide = uquit == QUIT_SUICIDE;
1243 events().send<event_type::game_over>( is_suicide, sLastWords );
1244 // Struck the save_player_data here to forestall Weirdness
1245 std::string char_filename = generate_memorial_filename( u.name );
1246 move_save_to_graveyard( char_filename );
1247 write_memorial_file( char_filename, sLastWords );
1248 memorial().clear();
1249 std::vector<std::string> characters = list_active_characters();
1250 // remove current player from the active characters list, as they are dead
1251 std::vector<std::string>::iterator curchar = std::find( characters.begin(),
1252 characters.end(), u.name );
1253 if( curchar != characters.end() ) {
1254 characters.erase( curchar );
1255 }
1256
1257 if( characters.empty() ) {
1258 bool queryDelete = false;
1259 bool queryReset = false;
1260
1261 if( get_option<std::string>( "WORLD_END" ) == "query" ) {
1262 bool decided = false;
1263 std::string buffer = _( "Warning: NPC interactions and some other global flags "
1264 "will not all reset when starting a new character in an "
1265 "already-played world. This can lead to some strange "
1266 "behavior.\n\n"
1267 "Are you sure you wish to keep this world?"
1268 );
1269
1270 while( !decided ) {
1271 uilist smenu;
1272 smenu.allow_cancel = false;
1273 smenu.addentry( 0, true, 'r', "%s", _( "Reset world" ) );
1274 smenu.addentry( 1, true, 'd', "%s", _( "Delete world" ) );
1275 smenu.addentry( 2, true, 'k', "%s", _( "Keep world" ) );
1276 smenu.query();
1277
1278 switch( smenu.ret ) {
1279 case 0:
1280 queryReset = true;
1281 decided = true;
1282 break;
1283 case 1:
1284 queryDelete = true;
1285 decided = true;
1286 break;
1287 case 2:
1288 decided = query_yn( buffer );
1289 break;
1290 }
1291 }
1292 }
1293
1294 if( queryDelete || get_option<std::string>( "WORLD_END" ) == "delete" ) {
1295 world_generator->delete_world( world_generator->active_world->world_name, true );
1296
1297 } else if( queryReset || get_option<std::string>( "WORLD_END" ) == "reset" ) {
1298 world_generator->delete_world( world_generator->active_world->world_name, false );
1299 }
1300 } else if( get_option<std::string>( "WORLD_END" ) != "keep" ) {
1301 std::string tmpmessage;
1302 for( auto &character : characters ) {
1303 tmpmessage += "\n ";
1304 tmpmessage += character;
1305 }
1306 popup( _( "World retained. Characters remaining:%s" ), tmpmessage );
1307 }
1308 if( gamemode ) {
1309 gamemode = std::make_unique<special_game>(); // null gamemode or something..
1310 }
1311 }
1312
1313 //Reset any offset due to driving
1315
1316 //clear all sound channels
1322
1323 MAPBUFFER.reset();
1325
1326#if defined(__ANDROID__)
1327 quick_shortcuts_map.clear();
1328#endif
1329 return true;
1330}
uint32_t UTF8_getch(const char **src, int *srclen)
Definition: catacharset.cpp:18
int utf8_width(const char *s, const bool ignore_tags)
std::string name
Definition: character.h:1504
A wrapper over a pointer to a curses window.
Definition: cursesdef.h:55
void send(const cata::event &) const
Definition: event_bus.cpp:58
void move_save_to_graveyard(const std::string &dirname)
Definition: game.cpp:2570
bool save_maps()
Definition: game.cpp:2834
std::unique_ptr< special_game > gamemode
Definition: game.h:1081
void death_screen()
Definition: game.cpp:2520
monster_range all_monsters()
Same as all_creatures but iterators only over monsters.
Definition: game.cpp:12088
bool save_factions_missions_npcs()
Definition: game.cpp:2820
void despawn_monster(monster &critter)
Despawn a specific monster, it's stored on the overmap.
Definition: game.cpp:11113
const kill_tracker & get_kill_tracker() const
Definition: game.cpp:984
void write_memorial_file(const std::string &filename, std::string sLastWords)
Writes information about the character out to a text file timestamped with the time of the file was m...
Definition: game.cpp:2933
std::vector< std::string > list_active_characters()
Returns a list of currently active character saves.
Definition: game.cpp:2918
bool save_artifacts()
Definition: game.cpp:2828
memorial_logger & memorial()
Definition: game.cpp:2883
void reset_npc_dispositions()
Definition: game.cpp:2792
int monster_kill_count() const
string_input_popup & max_length(int value)
Maximal amount of Unicode characters that can be given by the user.
const std::string & query_string(bool loop=true, bool draw_only=false)
string_input_popup & window(const catacurses::window &w, const point &start, int endx)
Set the window area where to display the input text.
A duration defined as a number of specific time units.
Definition: calendar.h:180
bool allow_cancel
Definition: ui.h:362
bool has_amount(const itype_id &what, int qty, bool pseudo=true, const std::function< bool(const item &)> &filter=return_true< item >) const
Check instance provides at least qty of an item (.
Definition: visitable.cpp:1108
#define c_white
Definition: color.h:18
#define c_light_gray
Definition: color.h:19
#define c_green
Definition: color.h:22
#define c_magenta
Definition: color.h:25
#define c_brown
Definition: color.h:26
#define c_red
Definition: color.h:21
static const itype_id itype_holybook_bible1("holybook_bible1")
static std::string generate_memorial_filename(const std::string &char_name)
Definition: game.cpp:1019
static const itype_id itype_holybook_bible2("holybook_bible2")
static const itype_id itype_holybook_bible3("holybook_bible3")
@ QUIT_DIED
Definition: game.h:72
@ QUIT_SUICIDE
Definition: game.h:69
const time_point & start_of_cataclysm
Definition: calendar.cpp:33
window newwin(int nlines, int ncols, const point &begin)
Definition: ncurses_def.cpp:34
FMT_CONSTEXPR bool find(Ptr first, Ptr last, T value, Ptr &out)
const size_t size
Definition: om_direction.h:27
void do_player_death_hurt(const player &target, bool death)
Definition: sounds.cpp:1633
void fade_audio_channel(channel channel, int duration)
Definition: sounds.cpp:1618
void fade_audio_group(group group, int duration)
Definition: sounds.cpp:1617
int TERMX
Definition: output.cpp:47
void mvwprintz(const catacurses::window &w, const point &p, const nc_color &FG, const std::string &text)
Definition: output.cpp:2035
int FULL_SCREEN_HEIGHT
Definition: output.cpp:56
int TERMY
Definition: output.cpp:48
void center_print(const catacurses::window &w, const int y, const nc_color &FG, const std::string &text)
Definition: output.cpp:446
void wprintz(const catacurses::window &w, const nc_color &FG, const std::string &text)
Definition: output.cpp:2043
int FULL_SCREEN_WIDTH
Definition: output.cpp:55
void mvwputch(const catacurses::window &w, const point &p, nc_color FG, int ch)
Definition: output.cpp:477
void draw_border(const catacurses::window &w, nc_color border_color, const std::string &title, nc_color title_color)
Definition: output.cpp:575
int mk_wcwidth(uint32_t ucs)
Definition: wcwidth.cpp:94

References _, uilist::addentry(), all_monsters(), uilist::allow_cancel, sfx::any, c_brown, c_green, c_light_gray, c_magenta, c_red, c_white, center_print(), memorial_logger::clear(), overmapbuffer::clear(), sfx::context_themes, death_screen(), despawn_monster(), sfx::do_player_death_hurt(), draw_border(), events(), sfx::fade_audio_channel(), sfx::fade_audio_group(), sfx::fatigue, detail::find(), FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, g, game_over, gamemode, generate_memorial_filename(), get_kill_tracker(), visitable< T >::has_amount(), Character::has_trait(), itype_holybook_bible1, itype_holybook_bible2, itype_holybook_bible3, list_active_characters(), MAPBUFFER, string_input_popup::max_length(), memorial(), mk_wcwidth(), kill_tracker::monster_kill_count(), move_save_to_graveyard(), mvwprintz(), mvwputch(), Character::name, catacurses::newwin(), overmap_buffer, point_zero, popup(), uilist::query(), string_input_popup::query_string(), query_yn(), QUIT_DIED, QUIT_SUICIDE, mapbuffer::reset(), reset_npc_dispositions(), uilist::ret, save_artifacts(), save_factions_missions_npcs(), save_maps(), event_bus::send(), set_driving_view_offset(), om_direction::size, calendar::start_of_cataclysm, string_format(), TERMX, TERMY, sfx::time_of_day, calendar::turn, u, uquit, UTF8_getch(), utf8_width(), sfx::weather, string_input_popup::window(), world_generator, wprintz(), and write_memorial_file().

Referenced by do_turn().

◆ cleanup_dead()

void game::cleanup_dead ( )

Definition at line 4187 of file game.cpp.

4188{
4189 // Dead monsters need to stay in the tracker until everything else that needs to die does so
4190 // This is because dying monsters can still interact with other dying monsters (@ref Creature::killer)
4191 bool monster_is_dead = critter_tracker->kill_marked_for_death();
4192
4193 bool npc_is_dead = false;
4194 // can't use all_npcs as that does not include dead ones
4195 for( const auto &n : active_npc ) {
4196 if( n->is_dead() ) {
4197 n->die( nullptr ); // make sure this has been called to create corpses etc.
4198 npc_is_dead = true;
4199 }
4200 }
4201
4202 if( monster_is_dead ) {
4203 // From here on, pointers to creatures get invalidated as dead creatures get removed.
4204 critter_tracker->remove_dead();
4205 }
4206
4207 if( npc_is_dead ) {
4208 for( auto it = active_npc.begin(); it != active_npc.end(); ) {
4209 if( ( *it )->is_dead() ) {
4210 remove_npc_follower( ( *it )->getID() );
4211 overmap_buffer.remove_npc( ( *it )->getID() );
4212 it = active_npc.erase( it );
4213 } else {
4214 it++;
4215 }
4216 }
4217 }
4218
4219 critter_died = false;
4220}
void remove_npc_follower(const character_id &id)
Remove follower id from follower set.
Definition: game.cpp:1989
pimpl< Creature_tracker > critter_tracker
Definition: game.h:999
std::list< shared_ptr_fast< npc > > active_npc
Definition: game.h:1063
bool critter_died
Has anything died in this turn and needs to be cleaned up?
Definition: game.h:1075
shared_ptr_fast< npc > remove_npc(const character_id &id)
Find npc by id and if found, erase it from the npc list and return it ( or return nullptr if not foun...

References active_npc, critter_died, critter_tracker, overmap_buffer, overmapbuffer::remove_npc(), and remove_npc_follower().

Referenced by do_turn(), and monmove().

◆ clear_zombies()

void game::clear_zombies ( )

Redirects to the creature_tracker clear() function.

Definition at line 4863 of file game.cpp.

4864{
4865 critter_tracker->clear();
4866}

References critter_tracker.

Referenced by setup().

◆ control_vehicle()

void game::control_vehicle ( )
private

Definition at line 5288 of file game.cpp.

5289{
5290 static const itype_id fuel_type_animal( "animal" );
5291 int veh_part = -1;
5292 vehicle *veh = remoteveh();
5293 if( veh == nullptr ) {
5294 if( const optional_vpart_position vp = m.veh_at( u.pos() ) ) {
5295 veh = &vp->vehicle();
5296 veh_part = vp->part_index();
5297 }
5298 }
5299 if( veh != nullptr && veh->player_in_control( u ) &&
5300 veh->avail_part_with_feature( veh_part, "CONTROLS", true ) >= 0 ) {
5301 veh->use_controls( u.pos() );
5302 } else if( veh && veh->player_in_control( u ) &&
5303 veh->avail_part_with_feature( veh_part, "CONTROL_ANIMAL", true ) >= 0 ) {
5304 u.controlling_vehicle = false;
5305 add_msg( m_info, _( "You let go of the reins." ) );
5306 } else if( veh && ( veh->avail_part_with_feature( veh_part, "CONTROLS", true ) >= 0 ||
5307 ( veh->avail_part_with_feature( veh_part, "CONTROL_ANIMAL", true ) >= 0 &&
5308 veh->has_engine_type( fuel_type_animal, false ) && veh->has_harnessed_animal() ) ) &&
5309 u.in_vehicle ) {
5310 if( u.has_trait( trait_WAYFARER ) ) {
5311 add_msg( m_info, _( "You refuse to take control of this vehicle." ) );
5312 return;
5313 }
5314 if( !veh->interact_vehicle_locked() ) {
5315 veh->handle_potential_theft( dynamic_cast<player &>( u ) );
5316 return;
5317 }
5318 if( veh->engine_on ) {
5319 if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
5320 return;
5321 }
5322 u.controlling_vehicle = true;
5323 add_msg( _( "You take control of the %s." ), veh->name );
5324 } else {
5325 if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
5326 return;
5327 }
5328 veh->start_engines( true );
5329 }
5330 } else { // Start looking for nearby vehicle controls.
5331 int num_valid_controls = 0;
5332 cata::optional<tripoint> vehicle_position;
5333 cata::optional<vpart_reference> vehicle_controls;
5334 for( const tripoint elem : m.points_in_radius( g->u.pos(), 1 ) ) {
5335 if( const optional_vpart_position vp = m.veh_at( elem ) ) {
5336 const cata::optional<vpart_reference> controls = vp.value().part_with_feature( "CONTROLS", true );
5337 if( controls ) {
5338 num_valid_controls++;
5339 vehicle_position = elem;
5340 vehicle_controls = controls;
5341 }
5342 }
5343 }
5344 if( num_valid_controls < 1 ) {
5345 add_msg( _( "No vehicle controls found." ) );
5346 return;
5347 } else if( num_valid_controls > 1 ) {
5348 vehicle_position = choose_adjacent( _( "Control vehicle where?" ) );
5349 if( !vehicle_position ) {
5350 return;
5351 }
5352 const optional_vpart_position vp = m.veh_at( *vehicle_position );
5353 if( vp ) {
5354 vehicle_controls = vp.value().part_with_feature( "CONTROLS", true );
5355 if( !vehicle_controls ) {
5356 add_msg( _( "The vehicle doesn't have controls there." ) );
5357 return;
5358 }
5359 } else {
5360 add_msg( _( "No vehicle there." ) );
5361 return;
5362 }
5363 }
5364 // If we hit neither of those, there's only one set of vehicle controls, which should already have been found.
5365 if( vehicle_controls ) {
5366 veh = &vehicle_controls->vehicle();
5367 if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
5368 return;
5369 }
5370 veh->use_controls( *vehicle_position );
5371 //May be folded up (destroyed), so need to re-get it
5372 veh = g->remoteveh();
5373 }
5374 }
5375 if( veh ) {
5376 // If we reached here, we gained control of a vehicle.
5377 // Clear the map memory for the area covered by the vehicle to eliminate ghost vehicles.
5378 for( const tripoint &target : veh->get_points() ) {
5379 u.clear_memorized_tile( m.getabs( target ) );
5380 }
5381 veh->is_following = false;
5382 veh->is_patrolling = false;
5383 veh->autopilot_on = false;
5384 veh->is_autodriving = false;
5385 }
5386}
cata::optional< tripoint > choose_adjacent(const std::string &message, const bool allow_vertical)
Request player input of adjacent tile, possibly including vertical tiles.
Definition: action.cpp:1023
bool in_vehicle
Definition: character.h:1511
void clear_memorized_tile(const tripoint &pos)
Definition: avatar.cpp:165
vehicle * remoteveh()
Returns the current remotely controlled vehicle.
Definition: game.cpp:2356
tripoint_range< tripoint > points_in_radius(const tripoint &center, size_t radius, size_t radiusz=0) const
Definition: map.cpp:8605
optional_vpart_position veh_at(const tripoint &p) const
Checks if tile is occupied by vehicle and by which part.
Definition: map.cpp:1009
Simple wrapper to forward functions that may return a cata::optional to vpart_position.
Definition: player.h:91
bool engine_on
Definition: vehicle.h:1989
std::set< tripoint > & get_points(bool force_refresh=false)
Definition: vehicle.cpp:6758
bool handle_potential_theft(player &p, bool check_only=false, bool prompt=true)
Definition: vehicle.cpp:4377
std::string name
Definition: vehicle.h:1849
bool has_engine_type(const itype_id &ft, bool enabled) const
Definition: vehicle.cpp:1031
void start_engines(bool take_control=false, bool autodrive=false)
void use_controls(const tripoint &pos)
Operate vehicle controls.
vehicle(const vproto_id &type_id, int init_veh_fuel=-1, int init_veh_status=-1)
Definition: vehicle.cpp:251
bool has_harnessed_animal() const
bool interact_vehicle_locked()
int avail_part_with_feature(int p, const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2545
bool autopilot_on
Definition: vehicle.h:1997
bool is_autodriving
Definition: vehicle.h:1982
cata::optional< vpart_reference > part_with_feature(const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2461
static const trait_id trait_WAYFARER("WAYFARER")

References _, add_msg(), vehicle::autopilot_on, vehicle::avail_part_with_feature(), choose_adjacent(), avatar::clear_memorized_tile(), Character::controlling_vehicle, vehicle::engine_on, fuel_type_animal, g, vehicle::get_points(), map::getabs(), vehicle::handle_potential_theft(), vehicle::has_engine_type(), vehicle::has_harnessed_animal(), Character::has_trait(), Character::in_vehicle, vehicle::interact_vehicle_locked(), vehicle::is_autodriving, vehicle::is_following, vehicle::is_patrolling, m, m_info, vehicle::name, vpart_position::part_with_feature(), vehicle::player_in_control(), map::points_in_radius(), Character::pos(), remoteveh(), vehicle::start_engines(), trait_WAYFARER, u, vehicle::use_controls(), cata::optional< T >::value(), map::veh_at(), and vehicle::vehicle().

Referenced by handle_action().

◆ create_or_get_main_ui_adaptor()

shared_ptr_fast< ui_adaptor > game::create_or_get_main_ui_adaptor ( )

In tiles mode w_terrain can have a different font (with a different tile dimension) or can be drawn by cata_tiles which uses tiles that again might have a different dimension then the normal font used everywhere else.

TERRAIN_WINDOW_WIDTH/TERRAIN_WINDOW_HEIGHT defines how many squares can be displayed in w_terrain (using it's specific tile dimension), not including partially drawn squares at the right/bottom. You should use it whenever you want to draw specific squares in that window or to determine whether a specific square is draw on screen (or outside the screen and needs scrolling).

TERRAIN_WINDOW_TERM_WIDTH/TERRAIN_WINDOW_TERM_HEIGHT defines the size of w_terrain in the standard font dimension (the font that everything else uses). You usually don't have to use it, expect for positioning of windows, because the window positions use the standard font dimension.

The code here calculates size available for w_terrain, caps it at max_view_size (the maximal view range than any character can have at any time). It is stored in TERRAIN_WINDOW_*.

Definition at line 3070 of file game.cpp.

3071{
3073 if( !ui ) {
3074 main_ui_adaptor = ui = make_shared_fast<ui_adaptor>();
3075 ui->on_redraw( []( const ui_adaptor & ) {
3076 g->draw();
3077 } );
3078 ui->on_screen_resize( [this]( ui_adaptor & ui ) {
3079 // remove some space for the sidebar, this is the maximal space
3080 // (using standard font) that the terrain window can have
3081 const int sidebar_left = panel_manager::get_manager().get_width_left();
3082 const int sidebar_right = panel_manager::get_manager().get_width_right();
3083
3085 TERRAIN_WINDOW_WIDTH = TERMX - ( sidebar_left + sidebar_right );
3088
3089 /**
3090 * In tiles mode w_terrain can have a different font (with a different
3091 * tile dimension) or can be drawn by cata_tiles which uses tiles that again
3092 * might have a different dimension then the normal font used everywhere else.
3093 *
3094 * TERRAIN_WINDOW_WIDTH/TERRAIN_WINDOW_HEIGHT defines how many squares can
3095 * be displayed in w_terrain (using it's specific tile dimension), not
3096 * including partially drawn squares at the right/bottom. You should
3097 * use it whenever you want to draw specific squares in that window or to
3098 * determine whether a specific square is draw on screen (or outside the screen
3099 * and needs scrolling).
3100 *
3101 * TERRAIN_WINDOW_TERM_WIDTH/TERRAIN_WINDOW_TERM_HEIGHT defines the size of
3102 * w_terrain in the standard font dimension (the font that everything else uses).
3103 * You usually don't have to use it, expect for positioning of windows,
3104 * because the window positions use the standard font dimension.
3105 *
3106 * The code here calculates size available for w_terrain, caps it at
3107 * max_view_size (the maximal view range than any character can have at
3108 * any time).
3109 * It is stored in TERRAIN_WINDOW_*.
3110 */
3112
3113 // Position of the player in the terrain window, it is always in the center
3116
3118 point( sidebar_left, 0 ) );
3119
3120 // minimap is always MINIMAP_WIDTH x MINIMAP_HEIGHT in size
3122
3123 // need to init in order to avoid crash. gets updated by the panel code.
3125
3126 ui.position_from_window( catacurses::stdscr );
3127 } );
3128 ui->mark_resize();
3129 }
3130 return ui;
3131}
catacurses::window w_pixel_minimap
Definition: game.h:1017
catacurses::window w_minimap_ptr
Definition: game.h:1054
weak_ptr_fast< ui_adaptor > main_ui_adaptor
Definition: game.h:1100
catacurses::window w_minimap
Definition: game.h:1016
catacurses::window w_terrain_ptr
Definition: game.h:1053
static panel_manager & get_manager()
Definition: panels.h:72
int get_width_right()
Definition: panels.cpp:2170
int get_width_left()
Definition: panels.cpp:2178
Adaptor between UI code and the UI management system.
Definition: ui_manager.h:65
static constexpr int MINIMAP_WIDTH
static constexpr int MINIMAP_HEIGHT
void to_map_font_dimension(int &, int &)
Definition: game_ui.cpp:20
std::shared_ptr< T > shared_ptr_fast
Definition: memory_fast.h:16
window stdscr
int TERRAIN_WINDOW_TERM_WIDTH
Definition: output.cpp:53
int TERRAIN_WINDOW_TERM_HEIGHT
Definition: output.cpp:54
int POSX
Definition: output.cpp:49
int TERRAIN_WINDOW_WIDTH
Definition: output.cpp:51
int POSY
Definition: output.cpp:50
int TERRAIN_WINDOW_HEIGHT
Definition: output.cpp:52

References g, panel_manager::get_manager(), panel_manager::get_width_left(), panel_manager::get_width_right(), main_ui_adaptor, MINIMAP_HEIGHT, MINIMAP_WIDTH, catacurses::newwin(), point_zero, POSX, POSY, catacurses::stdscr, TERMX, TERMY, TERRAIN_WINDOW_HEIGHT, TERRAIN_WINDOW_TERM_HEIGHT, TERRAIN_WINDOW_TERM_WIDTH, TERRAIN_WINDOW_WIDTH, to_map_font_dimension(), w_minimap, w_minimap_ptr, w_pixel_minimap, w_terrain, and w_terrain_ptr.

◆ create_starting_npcs()

void game::create_starting_npcs ( )
private

Definition at line 989 of file game.cpp.

990{
991 if( !get_option<bool>( "STATIC_NPC" ) ||
992 get_option<std::string>( "STARTING_NPC" ) == "never" ) {
993 return; //Do not generate a starting npc.
994 }
995
996 //We don't want more than one starting npc per starting location
997 const int radius = 1;
998 if( !overmap_buffer.get_npcs_near_player( radius ).empty() ) {
999 return; //There is already an NPC in this starting location
1000 }
1001
1002 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
1003 tmp->normalize();
1004 tmp->randomize( one_in( 2 ) ? NC_DOCTOR : NC_NONE );
1005 tmp->spawn_at_precise( { get_levx(), get_levy() }, u.pos() - point_south_east );
1007 tmp->form_opinion( u );
1008 tmp->set_attitude( NPCATT_NULL );
1009 //This sets the NPC mission. This NPC remains in the starting location.
1010 tmp->mission = NPC_MISSION_SHELTER;
1011 tmp->chatbin.first_topic = "TALK_SHELTER";
1012 tmp->toggle_trait( trait_id( "NPC_STARTING_NPC" ) );
1013 tmp->set_fac( faction_id( "no_faction" ) );
1014 //One random starting NPC mission
1015 tmp->add_new_mission( mission::reserve_random( ORIGIN_OPENER_NPC, tmp->global_omt_location(),
1016 tmp->getID() ) );
1017}
int get_levy() const
Definition: game.cpp:11978
int get_levx() const
The top left corner of the reality bubble (in submaps coordinates).
Definition: game.cpp:11973
static mission * reserve_random(mission_origin origin, const tripoint_abs_omt &p, const character_id &npc_id)
Definition: mission.cpp:200
std::vector< shared_ptr_fast< npc > > get_npcs_near_player(int radius)
Same as get_npcs_near(int,int,int,int) but uses player position as center.
void insert_npc(const shared_ptr_fast< npc > &who)
Adds the npc to an overmap ( based on the npcs current location ) and stores it there.
string_id< faction > faction_id
Definition: clzones.h:30
@ ORIGIN_OPENER_NPC
Definition: mission.h:45
@ NPCATT_NULL
Definition: npc.h:81
@ NPC_MISSION_SHELTER
Definition: npc.h:181
npc_class_id NC_NONE("NC_NONE")
npc_class_id NC_DOCTOR("NC_DOCTOR")
static constexpr point point_south_east
Definition: point.h:279
bool one_in(int chance)
Definition: rng.cpp:65

References get_levx(), get_levy(), overmapbuffer::get_npcs_near_player(), overmapbuffer::insert_npc(), NC_DOCTOR, NC_NONE, NPC_MISSION_SHELTER, NPCATT_NULL, one_in(), ORIGIN_OPENER_NPC, overmap_buffer, point_south_east, Character::pos(), mission::reserve_random(), trait_id, and u.

Referenced by start_game().

◆ critter_at() [1/2]

template<typename T >
T * game::critter_at ( const tripoint p,
bool  allow_hallucination = false 
)

Returns the Creature at the given location.

Optionally casted to the given type of creature: npc, player, monster - if there is a creature, but it's not of the requested type, returns nullptr.

Parameters
allow_hallucinationWhether to return monsters that are actually hallucinations.

Definition at line 4668 of file game.cpp.

4669{
4670 if( const shared_ptr_fast<monster> mon_ptr = critter_tracker->find( p ) ) {
4671 if( !allow_hallucination && mon_ptr->is_hallucination() ) {
4672 return nullptr;
4673 }
4674 // if we wanted to check for an NPC / player / avatar,
4675 // there is sometimes a monster AND an NPC/player there at the same time.
4676 // because the NPC/player etc may be riding that monster.
4677 // so only return the monster if we were actually looking for a monster.
4678 // otherwise, keep looking for the rider.
4679 // critter_at<creature> or critter_at() with no template will still default to returning monster first,
4680 // which is ok for the occasions where that happens.
4681 if( !mon_ptr->has_effect( effect_ridden ) || ( std::is_same<T, monster>::value ||
4682 std::is_same<T, Creature>::value || std::is_same<T, const monster>::value ||
4683 std::is_same<T, const Creature>::value ) ) {
4684 return dynamic_cast<T *>( mon_ptr.get() );
4685 }
4686 }
4687 if( !std::is_same<T, npc>::value && !std::is_same<T, const npc>::value ) {
4688 if( p == u.pos() ) {
4689 return dynamic_cast<T *>( &u );
4690 }
4691 }
4692 for( auto &cur_npc : active_npc ) {
4693 if( cur_npc->pos() == p && !cur_npc->is_dead() ) {
4694 return dynamic_cast<T *>( cur_npc.get() );
4695 }
4696 }
4697 return nullptr;
4698}
static const efftype_id effect_ridden("ridden")

References active_npc, critter_tracker, effect_ridden, Character::pos(), and u.

Referenced by draw_look_around_cursor(), examine(), find_or_make_stairs(), fling_creature(), forced_door_closing(), get_player_input(), is_empty(), knockback(), phasing_move(), print_all_tile_info(), spawn_hallucination(), swap_critters(), and update_stair_monsters().

◆ critter_at() [2/2]

template<typename T >
const T * game::critter_at ( const tripoint p,
bool  allow_hallucination = false 
) const

Definition at line 4701 of file game.cpp.

4702{
4703 return const_cast<game *>( this )->critter_at<T>( p, allow_hallucination );
4704}
Definition: game.h:144

◆ critter_by_id()

template<typename T >
template Creature * game::critter_by_id< Creature > ( const character_id id)
Returns
The living creature with the given id. Returns null if no living creature with such an id exists. Never returns a dead creature. Currently only the player character and npcs have ids.

Definition at line 4747 of file game.cpp.

4748{
4749 if( id == u.getID() ) {
4750 // player is always alive, therefore no is-dead check
4751 return dynamic_cast<T *>( &u );
4752 }
4753 return find_npc( id );
4754}
character_id getID() const
Definition: character.cpp:477
npc * find_npc(character_id id)
Find the npc with the given ID.
Definition: game.cpp:1978

References find_npc(), Character::getID(), and u.

◆ death_screen()

void game::death_screen ( )
private

Definition at line 2520 of file game.cpp.

2521{
2522 gamemode->game_over();
2526 follower_ids.clear();
2528}
stats_tracker & stats()
Definition: game.cpp:2878
void disp_NPC_epilogues()
Definition: game.cpp:2957
void display_faction_epilogues()
Definition: game.cpp:2974
void display_messages()
Definition: messages.cpp:801
void show_scores_ui(const achievements_tracker &achievements, stats_tracker &stats, const kill_tracker &kills)
Definition: scores_ui.cpp:69

References achievements_tracker_ptr, disp_NPC_epilogues(), display_faction_epilogues(), Messages::display_messages(), follower_ids, gamemode, get_kill_tracker(), show_scores_ui(), and stats().

Referenced by cleanup_at_end().

◆ despawn_monster()

void game::despawn_monster ( monster critter)

Despawn a specific monster, it's stored on the overmap.

Also removes it from the creature tracker. Keep in mind that any monster index may point to a different monster after calling this (or to no monster at all).

Definition at line 11113 of file game.cpp.

11114{
11115 if( !critter.is_hallucination() ) {
11116 // hallucinations aren't stored, they come and go as they like,
11118 }
11119
11120 critter.on_unload();
11121 remove_zombie( critter );
11122 // simulate it being dead so further processing of it (e.g. in monmove) will yield
11123 critter.set_hp( 0 );
11124}
void remove_zombie(const monster &critter)
Definition: game.cpp:4858
bool is_hallucination() const override
Definition: monster.cpp:2673
void on_unload()
Do some cleanup and caching as monster is being unloaded from map.
Definition: monster.cpp:3005
void set_hp(int hp)
Directly set the current hp of the monster (not capped at the maximal hp).
Definition: monster.cpp:1656
void despawn_monster(const monster &critter)
Despawn the monster back onto the overmap.

References overmapbuffer::despawn_monster(), monster::is_hallucination(), monster::on_unload(), overmap_buffer, remove_zombie(), and monster::set_hp().

Referenced by cleanup_at_end(), monmove(), place_player_overmap(), and shift_monsters().

◆ disable_robot()

bool game::disable_robot ( const tripoint p)

If there is a robot (that can be disabled), query the player and try to disable it.

Returns
true if the robot has been disabled or a similar action has been done. false if the player did not choose any action and the function has effectively done nothing.

Definition at line 8735 of file game.cpp.

8736{
8737 monster *const mon_ptr = critter_at<monster>( p );
8738 if( !mon_ptr ) {
8739 return false;
8740 }
8741 monster &critter = *mon_ptr;
8742 if( critter.friendly == 0 || critter.has_effect( effect_pet ) ||
8743 critter.has_flag( MF_RIDEABLE_MECH ) ||
8744 ( critter.has_flag( MF_PAY_BOT ) && critter.has_effect( effect_paid ) ) ) {
8745 // Can only disable / reprogram friendly monsters
8746 return false;
8747 }
8748 const auto mid = critter.type->id;
8749 const auto mon_item_id = critter.type->revert_to_itype;
8750 if( !mon_item_id.is_empty() &&
8751 query_yn( _( "Deactivate the %s?" ), critter.name() ) ) {
8752
8753 u.moves -= 100;
8754 m.add_item_or_charges( p, critter.to_item() );
8755 if( !critter.has_flag( MF_INTERIOR_AMMO ) ) {
8756 for( auto &ammodef : critter.ammo ) {
8757 if( ammodef.second > 0 ) {
8758 m.spawn_item( p.xy(), ammodef.first, 1, ammodef.second, calendar::turn );
8759 }
8760 }
8761 }
8762 remove_zombie( critter );
8763 return true;
8764 }
8765 // Manhacks are special, they have their own menu here.
8766 if( mid == mon_manhack ) {
8767 int choice = UILIST_CANCEL;
8768 if( critter.has_effect( effect_docile ) ) {
8769 choice = uilist( _( "Reprogram the manhack?" ), { _( "Engage targets." ) } );
8770 } else {
8771 choice = uilist( _( "Reprogram the manhack?" ), { _( "Follow me." ) } );
8772 }
8773 switch( choice ) {
8774 case 0:
8775 if( critter.has_effect( effect_docile ) ) {
8776 critter.remove_effect( effect_docile );
8777 if( one_in( 3 ) ) {
8778 add_msg( _( "The %s hovers momentarily as it surveys the area." ),
8779 critter.name() );
8780 }
8781 } else {
8782 critter.add_effect( effect_docile, 1_turns, num_bp );
8783 if( one_in( 3 ) ) {
8784 add_msg( _( "The %s lets out a whirring noise and starts to follow you." ),
8785 critter.name() );
8786 }
8787 }
8788 u.moves -= 100;
8789 return true;
8790 default:
8791 break;
8792 }
8793 }
8794 return false;
8795}
@ num_bp
Definition: bodypart.h:52
bool remove_effect(const efftype_id &eff_id, body_part bp=num_bp)
Removes a listed effect.
Definition: creature.cpp:1136
void spawn_item(const tripoint &p, const itype_id &type_id, unsigned quantity=1, int charges=0, const time_point &birthday=calendar::start_of_cataclysm, int damlevel=0)
Definition: map.cpp:4183
bool has_flag(m_flag f) const override
Definition: monster.cpp:889
item to_item() const
Convert this monster into an item (see mtype::revert_to_itype).
Definition: monster.cpp:2813
void add_effect(const efftype_id &eff_id, const time_duration &dur, const bodypart_str_id &bp, int intensity=0, bool force=false, bool deferred=false) override
Performs any monster-specific modifications to the arguments before passing to Creature::add_effect()...
Definition: monster.cpp:1832
int friendly
Definition: monster.h:474
std::string name(unsigned int quantity=1) const
Definition: monster.cpp:493
std::map< itype_id, int > ammo
Definition: monster.h:515
static const efftype_id effect_pet("pet")
static const efftype_id effect_docile("docile")
static const efftype_id effect_paid("paid")
static const mtype_id mon_manhack("mon_manhack")
@ MF_INTERIOR_AMMO
Definition: mtype.h:146
@ MF_RIDEABLE_MECH
Definition: mtype.h:115
@ MF_PAY_BOT
Definition: mtype.h:121
itype_id revert_to_itype
If this is not empty, the monster can be converted into an item of this type (if it's friendly).
Definition: mtype.h:364
constexpr point xy() const
Definition: point.h:220
const int UILIST_CANCEL
Definition: ui.h:28

References _, monster::add_effect(), map::add_item_or_charges(), add_msg(), monster::ammo, effect_docile, effect_paid, effect_pet, monster::friendly, Creature::has_effect(), monster::has_flag(), mtype::id, m, MF_INTERIOR_AMMO, MF_PAY_BOT, MF_RIDEABLE_MECH, mon_manhack, Creature::moves, monster::name(), num_bp, one_in(), query_yn(), Creature::remove_effect(), remove_zombie(), mtype::revert_to_itype, map::spawn_item(), monster::to_item(), calendar::turn, monster::type, u, UILIST_CANCEL, and tripoint::xy().

Referenced by examine().

◆ disp_NPC_epilogues()

void game::disp_NPC_epilogues ( )
private

Definition at line 2957 of file game.cpp.

2958{
2959 // TODO: This search needs to be expanded to all NPCs
2960 for( auto elem : follower_ids ) {
2962 if( !guy ) {
2963 continue;
2964 }
2965 const auto new_win = []() {
2967 point( std::max( 0, ( TERMX - FULL_SCREEN_WIDTH ) / 2 ),
2968 std::max( 0, ( TERMY - FULL_SCREEN_HEIGHT ) / 2 ) ) );
2969 };
2970 scrollable_text( new_win, guy->disp_name(), guy->get_epilogue() );
2971 }
2972}
shared_ptr_fast< npc > find_npc(character_id id)
Find the npc with the given ID.
void scrollable_text(const std::function< catacurses::window()> &init_window, const std::string &title, const std::string &text)
Definition: output.cpp:352

References overmapbuffer::find_npc(), follower_ids, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, catacurses::newwin(), overmap_buffer, scrollable_text(), TERMX, and TERMY.

Referenced by death_screen().

◆ disp_NPCs()

void game::disp_NPCs ( )

Definition at line 3008 of file game.cpp.

3009{
3010 const tripoint_abs_omt ppos = u.global_omt_location();
3011 const tripoint &lpos = u.pos();
3012 std::vector<shared_ptr_fast<npc>> npcs = overmap_buffer.get_npcs_near_player( 100 );
3013 std::sort( npcs.begin(), npcs.end(), npc_dist_to_player() );
3014
3016 ui_adaptor ui;
3017 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
3020 TERMY > FULL_SCREEN_HEIGHT ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0 ) );
3021 ui.position_from_window( w );
3022 } );
3023 ui.mark_resize();
3024 ui.on_redraw( [&]( const ui_adaptor & ) {
3025 werase( w );
3026 mvwprintz( w, point_zero, c_white, _( "Your overmap position: %s" ), ppos.to_string() );
3027 // NOLINTNEXTLINE(cata-use-named-point-constants)
3028 mvwprintz( w, point( 0, 1 ), c_white, _( "Your local position: %s" ), lpos.to_string() );
3029 size_t i;
3030 for( i = 0; i < 20 && i < npcs.size(); i++ ) {
3031 const tripoint_abs_omt apos = npcs[i]->global_omt_location();
3032 mvwprintz( w, point( 0, i + 3 ), c_white, "%s: %s", npcs[i]->name,
3033 apos.to_string() );
3034 }
3035 for( const monster &m : all_monsters() ) {
3036 mvwprintz( w, point( 0, i + 3 ), c_white, "%s: %d, %d, %d", m.name(),
3037 m.posx(), m.posy(), m.posz() );
3038 ++i;
3039 }
3040 wnoutrefresh( w );
3041 } );
3042
3043 input_context ctxt( "DISP_NPCS" );
3044 ctxt.register_action( "CONFIRM" );
3045 ctxt.register_action( "QUIT" );
3046 ctxt.register_action( "HELP_KEYBINDINGS" );
3047 bool stop = false;
3048 while( !stop ) {
3050 const std::string action = ctxt.handle_input();
3051 if( action == "CONFIRM" || action == "QUIT" ) {
3052 stop = true;
3053 }
3054 }
3055}
tripoint_abs_omt global_omt_location() const
Returns the location of the player in global overmap terrain coordinates.
Definition: character.cpp:6336
std::string to_string() const
Definition: coordinates.h:140
Represents a context in which a set of actions can be performed.
Definition: input.h:386
std::string name(const tripoint &p)
Definition: map.cpp:1325
void wnoutrefresh(const window &win)
Definition: ncurses_def.cpp:43
void werase(const window &win)
Definition: ncurses_def.cpp:53
std::string to_string() const
Definition: point.cpp:16

References _, action, all_monsters(), c_white, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, overmapbuffer::get_npcs_near_player(), Character::global_omt_location(), input_context::handle_input(), m, mvwprintz(), map::name(), om_direction::name(), catacurses::newwin(), overmap_buffer, point_zero, Character::pos(), ui_manager::redraw(), input_context::register_action(), TERMX, TERMY, coords::coord_point< Point, Origin, Scale >::to_string(), tripoint::to_string(), u, catacurses::werase(), and catacurses::wnoutrefresh().

◆ display_faction_epilogues()

void game::display_faction_epilogues ( )
private

Definition at line 2974 of file game.cpp.

2975{
2976 for( const auto &elem : faction_manager_ptr->all() ) {
2977 if( elem.second.known_by_u ) {
2978 const std::vector<std::string> epilogue = elem.second.epilogue();
2979 if( !epilogue.empty() ) {
2980 const auto new_win = []() {
2982 point( std::max( 0, ( TERMX - FULL_SCREEN_WIDTH ) / 2 ),
2983 std::max( 0, ( TERMY - FULL_SCREEN_HEIGHT ) / 2 ) ) );
2984 };
2985 scrollable_text( new_win, elem.second.name,
2986 std::accumulate( epilogue.begin() + 1, epilogue.end(), epilogue.front(),
2987 []( const std::string & lhs, const std::string & rhs ) -> std::string {
2988 return lhs + "\n" + rhs;
2989 } ) );
2990 }
2991 }
2992 }
2993}
pimpl< faction_manager > faction_manager_ptr
Definition: game.h:1000

References faction_manager_ptr, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, catacurses::newwin(), scrollable_text(), TERMX, and TERMY.

Referenced by death_screen().

◆ display_lighting()

void game::display_lighting ( )
private

Definition at line 11325 of file game.cpp.

11326{
11327 if( use_tiles ) {
11329 if( !g->display_overlay_state( ACTION_DISPLAY_LIGHTING ) ) {
11330 return;
11331 }
11332 uilist lighting_menu;
11333 std::vector<std::string> lighting_menu_strings{
11334 "Global lighting conditions"
11335 };
11336
11337 int count = 0;
11338 for( const auto &menu_str : lighting_menu_strings ) {
11339 lighting_menu.addentry( count++, true, MENU_AUTOASSIGN, "%s", menu_str );
11340 }
11341
11342 lighting_menu.w_y_setup = 0;
11343 lighting_menu.query();
11344 if( ( lighting_menu.ret >= 0 ) &&
11345 ( static_cast<size_t>( lighting_menu.ret ) < lighting_menu_strings.size() ) ) {
11346 g->displaying_lighting_condition = lighting_menu.ret;
11347 }
11348 }
11349}
@ ACTION_DISPLAY_LIGHTING
Toggle lighting conditions map.
Definition: action.h:319
bool use_tiles
Use tiles for display.
void display_toggle_overlay(action_id)
Definition: game.cpp:11221
pos_scalar w_y_setup
Definition: ui.h:338
constexpr size_t count()
Definition: fmtlib_core.h:1073
const int MENU_AUTOASSIGN
Definition: ui.h:31

References ACTION_DISPLAY_LIGHTING, uilist::addentry(), detail::count(), display_toggle_overlay(), g, MENU_AUTOASSIGN, uilist::query(), uilist::ret, use_tiles, and uilist::w_y_setup.

Referenced by handle_action(), and look_around().

◆ display_overlay_state()

bool game::display_overlay_state ( action_id  action)

Definition at line 11216 of file game.cpp.

11217{
11219}
cata::optional< action_id > displaying_overlays
Definition: game.h:945

References action, and displaying_overlays.

Referenced by display_toggle_overlay(), and display_visibility().

◆ display_radiation()

void game::display_radiation ( )
private

Definition at line 11351 of file game.cpp.

11352{
11353 if( use_tiles ) {
11355 }
11356}
@ ACTION_DISPLAY_RADIATION
Toggle radiation map.
Definition: action.h:321

References ACTION_DISPLAY_RADIATION, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_scent()

void game::display_scent ( )
private

Definition at line 11230 of file game.cpp.

11231{
11232 if( use_tiles ) {
11234 } else {
11235 int div;
11236 bool got_value = query_int( div, _( "Set the Scent Map sensitivity to (0 to cancel)?" ) );
11237 if( !got_value || div < 1 ) {
11238 add_msg( _( "Never mind." ) );
11239 return;
11240 }
11241 shared_ptr_fast<game::draw_callback_t> scent_cb = make_shared_fast<game::draw_callback_t>( [&]() {
11242 scent.draw( w_terrain, div * 2, u.pos() + u.view_offset );
11243 } );
11244 g->add_draw_callback( scent_cb );
11245
11248 }
11249}
@ ACTION_DISPLAY_SCENT
Toggle scent map.
Definition: action.h:281
void wait_for_any_key()
Wait until the user presses a key.
Definition: input.cpp:1309
tripoint view_offset
Definition: player.h:589
void draw(const catacurses::window &win, int div, const tripoint &center) const
Definition: scent_map.cpp:70
input_manager inp_mngr
Definition: input.cpp:109
bool query_int(int &result, int default_val, const std::string &text)
Definition: output.cpp:718

References _, ACTION_DISPLAY_SCENT, add_msg(), display_toggle_overlay(), scent_map::draw(), g, inp_mngr, Character::pos(), query_int(), ui_manager::redraw(), scent, u, use_tiles, player::view_offset, w_terrain, and input_manager::wait_for_any_key().

Referenced by handle_action(), and look_around().

◆ display_temperature()

void game::display_temperature ( )
private

Definition at line 11251 of file game.cpp.

11252{
11253 if( use_tiles ) {
11255 }
11256}
@ ACTION_DISPLAY_TEMPERATURE
Toggle temperature map.
Definition: action.h:313

References ACTION_DISPLAY_TEMPERATURE, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_toggle_overlay()

void game::display_toggle_overlay ( action_id  action)

Definition at line 11221 of file game.cpp.

11222{
11223 if( display_overlay_state( action ) ) {
11224 displaying_overlays.reset();
11225 } else {
11227 }
11228}
bool display_overlay_state(action_id)
Definition: game.cpp:11216

References action, display_overlay_state(), and displaying_overlays.

Referenced by display_lighting(), display_radiation(), display_scent(), display_temperature(), display_transparency(), display_vehicle_ai(), and display_visibility().

◆ display_transparency()

void game::display_transparency ( )
private

Definition at line 11358 of file game.cpp.

11359{
11360 if( use_tiles ) {
11362 }
11363}
@ ACTION_DISPLAY_TRANSPARENCY
Toggle transparency map.
Definition: action.h:323

References ACTION_DISPLAY_TRANSPARENCY, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_vehicle_ai()

void game::display_vehicle_ai ( )
private

Definition at line 11258 of file game.cpp.

11259{
11260 if( use_tiles ) {
11262 }
11263}
@ ACTION_DISPLAY_VEHICLE_AI
Toggle vehicle autopilot data.
Definition: action.h:315

References ACTION_DISPLAY_VEHICLE_AI, display_toggle_overlay(), and use_tiles.

Referenced by handle_action().

◆ display_visibility()

void game::display_visibility ( )
private

Definition at line 11265 of file game.cpp.

11266{
11267 if( use_tiles ) {
11270 std::vector< tripoint > locations;
11271 uilist creature_menu;
11272 int num_creatures = 0;
11273 creature_menu.addentry( num_creatures++, true, MENU_AUTOASSIGN, "%s", _( "You" ) );
11274 locations.emplace_back( g->u.pos() ); // add player first.
11275 for( const Creature &critter : g->all_creatures() ) {
11276 if( critter.is_player() ) {
11277 continue;
11278 }
11279 creature_menu.addentry( num_creatures++, true, MENU_AUTOASSIGN, critter.disp_name() );
11280 locations.emplace_back( critter.pos() );
11281 }
11282
11283 pointmenu_cb callback( locations );
11284 creature_menu.callback = &callback;
11285 creature_menu.w_y_setup = 0;
11286 creature_menu.query();
11287 if( creature_menu.ret >= 0 && static_cast<size_t>( creature_menu.ret ) < locations.size() ) {
11288 Creature *creature = critter_at<Creature>( locations[creature_menu.ret] );
11290 }
11291 } else {
11293 }
11294 }
11295}
@ ACTION_DISPLAY_VISIBILITY
Toggle visibility map.
Definition: action.h:317
size_t num_creatures() const
Returns the approximate number of creatures in the reality bubble.
Definition: game.cpp:4848
Creature * displaying_visibility_creature
Creature for which to display the visibility map.
Definition: game.h:1036
Callback for uilist that pairs menu entries with points When an entry is selected,...
Definition: ui.h:423
uilist_callback * callback
Definition: ui.h:335
generic_factory< overmap_location > locations("overmap location")

References _, ACTION_DISPLAY_VISIBILITY, uilist::addentry(), uilist::callback, creature, display_overlay_state(), display_toggle_overlay(), displaying_visibility_creature, g, anonymous_namespace{overmap_location.cpp}::locations, MENU_AUTOASSIGN, num_creatures(), uilist::query(), uilist::ret, use_tiles, and uilist::w_y_setup.

Referenced by handle_action().

◆ do_turn()

bool game::do_turn ( )

MAIN GAME LOOP.

Returns true if game is over (death, saved, quit, etc.).

Definition at line 1452 of file game.cpp.

1453{
1454 if( is_game_over() ) {
1455 return cleanup_at_end();
1456 }
1457 // Actual stuff
1458 if( new_game ) {
1459 new_game = false;
1460 } else {
1461 gamemode->per_turn();
1462 calendar::turn += 1_turns;
1463 }
1464
1465 // starting a new turn, clear out temperature cache
1467 weather.clear_temp_cache();
1468
1469 if( npcs_dirty ) {
1470 load_npcs();
1471 }
1472
1475 // If controlling a vehicle that is owned by someone else
1477 vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
1478 if( veh && !veh->handle_potential_theft( dynamic_cast<player &>( u ), true ) ) {
1479 veh->handle_potential_theft( dynamic_cast<player &>( u ), false, false );
1480 }
1481 }
1482 // If riding a horse - chance to spook
1483 if( u.is_mounted() ) {
1485 }
1486 if( calendar::once_every( 1_days ) ) {
1488 }
1489
1490 // Move hordes every 2.5 min
1493 // Hordes that reached the reality bubble need to spawn,
1494 // make them spawn in invisible areas only.
1495 m.spawn_monsters( false );
1496 }
1497
1499
1500 u.update_body();
1501
1502 // Auto-save if autosave is enabled
1503 if( get_option<bool>( "AUTOSAVE" ) &&
1504 calendar::once_every( 1_turns * get_option<int>( "AUTOSAVE_TURNS" ) ) &&
1505 !u.is_dead_state() ) {
1506 autosave();
1507 }
1508
1509 weather.update_weather();
1511
1515 // Process NPC sound events before they move or they hear themselves talking
1516 for( npc &guy : all_npcs() ) {
1517 if( rl_dist( guy.pos(), u.pos() ) < MAX_VIEW_DISTANCE ) {
1519 }
1520 }
1521
1522 // Process sound events into sound markers for display to the player.
1524
1525 if( u.is_deaf() ) {
1527 }
1528
1529 if( !u.has_effect( effect_sleep ) || uquit == QUIT_WATCH ) {
1530 if( u.moves > 0 || uquit == QUIT_WATCH ) {
1531 while( u.moves > 0 || uquit == QUIT_WATCH ) {
1532 cleanup_dead();
1534 // Process any new sounds the player caused during their turn.
1535 for( npc &guy : all_npcs() ) {
1536 if( rl_dist( guy.pos(), u.pos() ) < MAX_VIEW_DISTANCE ) {
1538 }
1539 }
1542 wait_popup.reset();
1544 }
1545
1546 if( queue_screenshot ) {
1550 queue_screenshot = false;
1551 }
1552
1553 if( handle_action() ) {
1555 u.action_taken();
1556 }
1557
1558 if( is_game_over() ) {
1559 return cleanup_at_end();
1560 }
1561
1562 if( uquit == QUIT_WATCH ) {
1563 break;
1564 }
1565 if( u.activity ) {
1567 }
1568 }
1569 // Reset displayed sound markers now that the turn is over.
1570 // We only want this to happen if the player had a chance to examine the sounds.
1572 }
1573 }
1574
1575 if( driving_view_offset.x != 0 || driving_view_offset.y != 0 ) {
1576 // Still have a view offset, but might not be driving anymore,
1577 // or the option has been deactivated,
1578 // might also happen when someone dives from a moving car.
1579 // or when using the handbrake.
1580 vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
1581 calc_driving_offset( veh );
1582 }
1583
1584 // No-scent debug mutation has to be processed here or else it takes time to start working
1585 if( !u.has_active_bionic( bionic_id( "bio_scent_mask" ) ) &&
1586 !u.has_trait( trait_id( "DEBUG_NOSCENT" ) ) ) {
1589 }
1590 scent.update( u.pos(), m );
1591
1592 // We need floor cache before checking falling 'n stuff
1594
1597 m.vehmove();
1598 m.process_fields();
1599 m.process_items();
1602
1603 // Apply sounds from previous turn to monster and NPC AI.
1605 // Update vision caches for monsters. If this turns out to be expensive,
1606 // consider a stripped down cache just for monsters.
1607 m.build_map_cache( get_levz(), true );
1608 monmove();
1609 if( calendar::once_every( 5_minutes ) ) {
1611 }
1612 if( calendar::once_every( 10_seconds ) ) {
1613 for( const tripoint &elem : m.get_furn_field_locations() ) {
1614 const auto &furn = m.furn( elem ).obj();
1615 for( const emit_id &e : furn.emissions ) {
1616 m.emit_field( elem, e );
1617 }
1618 }
1619 }
1622 u.process_turn();
1623
1625 cleanup_dead();
1626
1627 if( u.moves < 0 && get_option<bool>( "FORCE_REDRAW" ) ) {
1630 }
1631
1632 if( get_levz() >= 0 && !u.is_underwater() ) {
1633 handle_weather_effects( weather.weather_id );
1634 }
1635
1636 const bool player_is_sleeping = u.has_effect( effect_sleep );
1637 bool wait_redraw = false;
1638 std::string wait_message;
1639 time_duration wait_refresh_rate;
1640 if( player_is_sleeping ) {
1641 wait_redraw = true;
1642 wait_message = _( "Wait till you wake up…" );
1643 wait_refresh_rate = 30_minutes;
1644 if( calendar::once_every( 1_hours ) ) {
1646 }
1647 } else if( u.has_destination() ) {
1648 wait_redraw = true;
1649 wait_message = _( "Travelling…" );
1650 wait_refresh_rate = 15_turns;
1651 } else if( const cata::optional<std::string> progress = u.activity.get_progress_message( u ) ) {
1652 wait_redraw = true;
1653 wait_message = *progress;
1654 if( u.activity.id() == ACT_AUTODRIVE ) {
1655 wait_refresh_rate = 1_turns;
1656 } else {
1657 wait_refresh_rate = 5_minutes;
1658 }
1659 }
1660 if( wait_redraw ) {
1662 calendar::once_every( std::min( 1_minutes, wait_refresh_rate ) ) ) {
1663 if( first_redraw_since_waiting_started || calendar::once_every( wait_refresh_rate ) ) {
1665 }
1666
1667 // Avoid redrawing the main UI every time due to invalidation
1669 wait_popup = std::make_unique<static_popup>();
1670 wait_popup->on_top( true ).wait_message( "%s", wait_message );
1674 }
1675 } else {
1676 // Nothing to wait for now
1677 wait_popup.reset();
1679 }
1680
1682 u.update_body_wetness( get_weather().get_precise() );
1683 u.apply_wetness_morale( weather.temperature );
1684
1685 if( calendar::once_every( 1_minutes ) ) {
1686 u.update_morale();
1687 }
1688
1689 if( calendar::once_every( 9_turns ) ) {
1691 }
1692
1693 if( !u.is_deaf() ) {
1695 }
1700
1701 // reset player noise
1702 u.volume = 0;
1703
1704 return false;
1705}
void update_morale()
Ticks down morale counters and removes them.
Definition: character.cpp:9005
void action_taken()
Called after every action, invalidates player caches.
Definition: character.cpp:877
bool check_mount_is_spooked()
Definition: character.cpp:1102
void update_bodytemp(const map &m, const weather_manager &weather)
Maintains body temperature.
Definition: character.cpp:5183
bool is_mounted() const
Definition: character.cpp:1143
bool has_destination() const
scenttype_id get_type_of_scent() const
Definition: character.cpp:8764
bool check_and_recover_morale()
Checks permanent morale for consistency and recovers it when an inconsistency is found.
Definition: character.cpp:9132
bool is_deaf() const
Definition: character.cpp:4486
void update_body()
Updates all "biology" by one turn.
Definition: character.cpp:4665
bool has_active_bionic(const bionic_id &b) const
Returns true if the player has the entered bionic id and it is powered on.
Definition: character.cpp:1887
void apply_wetness_morale(int temperature)
Recalculates morale penalty/bonus from wetness based on mutations, equipment and temperature.
Definition: suffer.cpp:1804
virtual bool is_underwater() const
Definition: creature.cpp:174
int get_levz() const
Definition: game.cpp:11983
void overmap_npc_move()
Definition: game.cpp:4347
class game::debug_hour_timer debug_hour_timer
npc_range all_npcs()
Same as all_creatures but iterators only over npcs.
Definition: game.cpp:12093
void monmove()
Definition: game.cpp:4222
void autopilot_vehicles()
process vehicles that are following the player
Definition: game.cpp:1770
void add_artifact_dreams()
Definition: game.cpp:11927
int moves_since_last_save
Definition: game.h:1066
bool take_screenshot() const
Saves a screenshot of the current viewport, as a PNG file.
Definition: game.cpp:7259
void calc_driving_offset(vehicle *veh=nullptr)
Definition: game.cpp:1350
bool cleanup_at_end()
Definition: game.cpp:1046
std::unique_ptr< static_popup > wait_popup
Definition: game.h:1102
bool queue_screenshot
Definition: game.h:1045
friend weather_manager & get_weather()
Definition: weather.cpp:64
void autosave()
Definition: game.cpp:11416
void process_activity()
Definition: game.cpp:1759
void update_stair_monsters()
Definition: game.cpp:10904
void process_voluntary_act_interrupt()
Definition: game.cpp:1719
void load_npcs()
Makes any nearby NPCs on the overmap active.
Definition: game.cpp:914
bool npcs_dirty
Has a NPC been spawned since last load?
Definition: game.h:1073
void cleanup_dead()
Definition: game.cpp:4187
bool is_game_over()
Definition: game.cpp:2473
void perhaps_add_random_npc()
Definition: game.cpp:11151
void mon_info_update()
Definition: game.cpp:3986
bool handle_action()
const T & obj() const
Definition: ammo_effect.cpp:26
void build_floor_caches()
Definition: map.cpp:8049
void process_falling()
Invoked drop_everything on cached dirty tiles.
Definition: map.cpp:2274
void emit_field(const tripoint &pos, const emit_id &src, float mul=1.0f)
Runs one cycle of emission src which may result in propagation of fields.
Definition: map_field.cpp:1928
const std::vector< tripoint > & get_furn_field_locations() const
Definition: map.cpp:7746
void spawn_monsters(bool ignore_sight)
Spawn monsters from submap spawn points and from the overmap.
Definition: map.cpp:7705
void vehmove()
Definition: map.cpp:414
void creature_in_field(Creature &critter)
Apply field effects to the creature when it's on a square with fields.
Definition: map_field.cpp:1563
void process_fields()
Definition: map_field.cpp:141
furn_id furn(const tripoint &p) const
Definition: map.cpp:1348
void build_map_cache(int zlev, bool skip_lightmap=false)
Definition: map.cpp:8215
void process_items()
Definition: map.cpp:4569
static void process_all()
Handles mission deadline processing.
Definition: mission.cpp:98
void set_scent(const tripoint_abs_omt &loc, int strength)
Method to set a scent trace.
void process_mongroups()
Process nearby monstergroups (dying mostly).
void move_hordes()
Let hordes move a step.
const activity_id & id() const
cata::optional< std::string > get_progress_message(const avatar &u) const
Helper that returns an activity specific progress message.
bool is_dead_state() const override
Returns true if the player should be dead.
Definition: player.cpp:777
int volume
Definition: player.h:592
int scent
Definition: player.h:601
void update_body_wetness(const w_point &weather)
Maintains body wetness and handles the rate at which the player dries.
Definition: player.cpp:1564
void process_turn() override
Resets movement points and applies other non-idempotent changes.
Definition: player.cpp:277
void set(const tripoint &p, int value, const scenttype_id &type=scenttype_id())
Get the scent value at the given position.
Definition: scent_map.cpp:102
void update(const tripoint &center, map &m)
Definition: scent_map.cpp:150
static constexpr time_duration from_minutes(const T m)
Definition: calendar.h:212
void process()
Process all queued events, potentially altering the game state and modifying the event queue.
static const activity_id ACT_AUTODRIVE("ACT_AUTODRIVE")
static const efftype_id effect_sleep("sleep")
@ QUIT_WATCH
Definition: game.h:73
static constexpr int MAX_VIEW_DISTANCE
void handle_weather_effects(const weather_type_id &w)
Definition: weather.cpp:522
bool once_every(const time_duration &event_frequency)
Predicate to handle rate-limiting.
Definition: calendar.cpp:490
explosion_queue & get_explosion_queue()
Definition: explosion.cpp:1261
void do_vehicle_engine_sfx()
Definition: sounds.cpp:1614
void do_hearing_loss(int turns=-1)
Definition: sounds.cpp:1609
void do_danger_music()
Definition: sounds.cpp:1613
void do_vehicle_exterior_engine_sfx()
Definition: sounds.cpp:1615
void do_fatigue()
Definition: sounds.cpp:1634
void remove_hearing_loss()
Definition: sounds.cpp:1610
void process_sound_markers(player *p)
Definition: sounds.cpp:386
void process_sounds()
Definition: sounds.cpp:304
void reset_markers()
Definition: sounds.cpp:572
vehicle * veh_pointer_or_null(const optional_vpart_position &p)

References _, ACT_AUTODRIVE, Character::action_taken(), Character::activity, add_artifact_dreams(), all_npcs(), Character::apply_wetness_morale(), autopilot_vehicles(), autosave(), map::build_floor_caches(), map::build_map_cache(), calc_driving_offset(), Character::check_and_recover_morale(), Character::check_mount_is_spooked(), cleanup_at_end(), cleanup_dead(), Character::controlling_vehicle, map::creature_in_field(), sfx::do_danger_music(), sfx::do_fatigue(), sfx::do_hearing_loss(), sfx::do_vehicle_engine_sfx(), sfx::do_vehicle_exterior_engine_sfx(), driving_view_offset, effect_sleep, map::emit_field(), explosion_handler::explosion_queue::execute(), first_redraw_since_waiting_started, time_duration::from_minutes(), map::furn(), gamemode, explosion_handler::get_explosion_queue(), map::get_furn_field_locations(), get_levz(), player_activity::get_progress_message(), Character::get_type_of_scent(), get_weather, Character::global_omt_location(), grid_tracker_ptr, handle_action(), vehicle::handle_potential_theft(), handle_weather_effects(), Character::has_active_bionic(), Character::has_destination(), Character::has_distant_destination(), Creature::has_effect(), Character::has_trait(), player_activity::id(), Character::in_vehicle, invalidate_main_ui_adaptor(), player::is_dead_state(), Character::is_deaf(), is_game_over(), Character::is_mounted(), Creature::is_underwater(), load_npcs(), m, MAX_VIEW_DISTANCE, mon_info_update(), monmove(), overmapbuffer::move_hordes(), Creature::moves, moves_since_last_save, new_game, npcs_dirty, int_id< T >::obj(), calendar::once_every(), overmap_buffer, overmap_npc_move(), perhaps_add_random_npc(), Character::pos(), game::debug_hour_timer::print_time(), timed_event_manager::process(), process_activity(), mission::process_all(), map::process_falling(), map::process_fields(), map::process_items(), overmapbuffer::process_mongroups(), sounds::process_sound_markers(), sounds::process_sounds(), player::process_turn(), process_voluntary_act_interrupt(), queue_screenshot, QUIT_WATCH, ui_manager::redraw(), refresh_display(), sfx::remove_hearing_loss(), reset_light_level(), sounds::reset_markers(), rl_dist(), scent, player::scent, scent_map::set(), overmapbuffer::set_scent(), map::spawn_monsters(), take_screenshot(), timed_events, calendar::turn, u, scent_map::update(), Character::update_body(), player::update_body_wetness(), Character::update_bodytemp(), Character::update_morale(), update_stair_monsters(), uquit, map::veh_at(), veh_pointer_or_null(), map::vehmove(), player::volume, wait_popup, point::x, and point::y.

◆ draw()

void game::draw ( )

Definition at line 3245 of file game.cpp.

3246{
3247 if( test_mode ) {
3248 return;
3249 }
3250
3251 //temporary fix for updating visibility for minimap
3252 ter_view_p.z = ( u.pos() + u.view_offset ).z;
3255
3256 werase( w_terrain );
3257 draw_ter();
3258 for( auto it = draw_callbacks.begin(); it != draw_callbacks.end(); ) {
3259 shared_ptr_fast<draw_callback_t> cb = it->lock();
3260 if( cb ) {
3261 ( *cb )();
3262 ++it;
3263 } else {
3264 it = draw_callbacks.erase( it );
3265 }
3266 }
3268
3269 draw_panels( true );
3270}
bool test_mode
Set to true when running in test mode (e.g.
tripoint ter_view_p
Definition: game.h:1012
void draw_panels(bool force_draw=false)
Definition: game.cpp:3272
void draw_ter(bool draw_sounds=true)
Definition: game.cpp:3386
void update_visibility_cache(int zlev)
Definition: map.cpp:5596
int z
Definition: point.h:152

References map::build_map_cache(), draw_callbacks, draw_panels(), draw_ter(), m, Character::pos(), ter_view_p, test_mode, u, map::update_visibility_cache(), player::view_offset, w_terrain, catacurses::werase(), catacurses::wnoutrefresh(), and tripoint::z.

◆ draw_below_override()

void game::draw_below_override ( const tripoint p,
bool  draw 
)

Definition at line 963 of file animation.cpp.

964{
965}

◆ draw_bullet()

void game::draw_bullet ( const tripoint t,
int  i,
const std::vector< tripoint > &  trajectory,
char  bullet 
)

Definition at line 518 of file animation.cpp.

520{
521 draw_bullet_curses( m, t, bullet, &trajectory[i] );
522}
void draw_bullet_curses(map &m, const tripoint &t, const char bullet, const tripoint *const p)
Definition: animation.cpp:459
std::vector< tripoint > trajectory
Definition: ranged.h:32

References anonymous_namespace{animation.cpp}::draw_bullet_curses(), and m.

◆ draw_critter()

void game::draw_critter ( const Creature critter,
const tripoint center 
)

Definition at line 3368 of file game.cpp.

3369{
3370 draw_critter_internal( w_terrain, critter, center, false, m, u );
3371}
static void draw_critter_internal(const catacurses::window &w, const Creature &critter, const tripoint &center, bool inverted, const map &m, const avatar &u)
Definition: game.cpp:3335

References center, draw_critter_internal(), m, u, and w_terrain.

Referenced by draw_ter().

◆ draw_critter_highlighted()

void game::draw_critter_highlighted ( const Creature critter,
const tripoint center 
)

Definition at line 3373 of file game.cpp.

3374{
3375 draw_critter_internal( w_terrain, critter, center, true, m, u );
3376}

References center, draw_critter_internal(), m, u, and w_terrain.

◆ draw_cursor()

void game::draw_cursor ( const tripoint p)

Definition at line 724 of file animation.cpp.

725{
726 const tripoint rp = relative_view_pos( *this, p );
727 mvwputch_inv( w_terrain, rp.xy(), c_light_green, 'X' );
728}
#define c_light_green
Definition: color.h:28
tripoint relative_view_pos(const game &g, const tripoint &p) noexcept
Definition: animation.cpp:127
void mvwputch_inv(const catacurses::window &w, const point &p, nc_color FG, int ch)
Definition: output.cpp:491

References c_light_green, mvwputch_inv(), anonymous_namespace{animation.cpp}::relative_view_pos(), w_terrain, and tripoint::xy().

Referenced by draw_look_around_cursor().

◆ draw_field_override()

void game::draw_field_override ( const tripoint p,
const field_type_id id 
)

Definition at line 919 of file animation.cpp.

920{
921}

◆ draw_furniture_override()

void game::draw_furniture_override ( const tripoint p,
const furn_id id 
)

Definition at line 880 of file animation.cpp.

881{
882}

◆ draw_graffiti_override()

void game::draw_graffiti_override ( const tripoint p,
bool  has 
)

Definition at line 893 of file animation.cpp.

894{
895}

◆ draw_highlight()

void game::draw_highlight ( const tripoint p)

Definition at line 737 of file animation.cpp.

738{
739 // Do nothing
740}

◆ draw_hit_mon()

void game::draw_hit_mon ( const tripoint p,
const monster m,
bool  dead = false 
)

Definition at line 581 of file animation.cpp.

582{
583 draw_hit_mon_curses( p, m, u, dead );
584}
void draw_hit_mon_curses(const tripoint &center, const monster &m, const player &u, const bool dead)
Definition: animation.cpp:552

References dead, anonymous_namespace{animation.cpp}::draw_hit_mon_curses(), m, and u.

◆ draw_hit_player()

void game::draw_hit_player ( const Character p,
int  dam 
)

Definition at line 626 of file animation.cpp.

627{
628 draw_hit_player_curses( *this, p, dam );
629}
void draw_hit_player_curses(const game &g, const Character &p, const int dam)
Definition: animation.cpp:589

References anonymous_namespace{animation.cpp}::draw_hit_player_curses().

◆ draw_item_override()

void game::draw_item_override ( const tripoint p,
const itype_id id,
const mtype_id mid,
bool  hilite 
)

Definition at line 933 of file animation.cpp.

935{
936}

◆ draw_line() [1/2]

void game::draw_line ( const tripoint p,
const std::vector< tripoint > &  points 
)

Definition at line 710 of file animation.cpp.

711{
712 draw_line_curses( *this, points );
713}
void draw_line_curses(game &g, const std::vector< tripoint > &points)
Definition: animation.cpp:690

References anonymous_namespace{animation.cpp}::draw_line_curses().

◆ draw_line() [2/2]

void game::draw_line ( const tripoint p,
const tripoint center_point,
const std::vector< tripoint > &  points,
bool  noreveal = false 
)

Definition at line 677 of file animation.cpp.

679{
680 if( !u.sees( p ) ) {
681 return;
682 }
683
684 draw_line_curses( *this, center, points, noreveal );
685}

References center, anonymous_namespace{animation.cpp}::draw_line_curses(), Character::sees(), and u.

Referenced by draw_ter().

◆ draw_look_around_cursor()

void game::draw_look_around_cursor ( const tripoint lp,
const visibility_variables cache 
)

Definition at line 5796 of file game.cpp.

5797{
5798 if( !liveview.is_enabled() ) {
5799#if defined( TILES )
5800 if( is_draw_tiles_mode() ) {
5801 draw_cursor( lp );
5802 return;
5803 }
5804#endif
5805 const tripoint view_center = u.pos() + u.view_offset;
5806 visibility_type visibility = VIS_HIDDEN;
5807 const bool inbounds = m.inbounds( lp );
5808 if( inbounds ) {
5809 visibility = m.get_visibility( m.apparent_light_at( lp, cache ), cache );
5810 }
5811 if( visibility == VIS_CLEAR ) {
5812 const Creature *const creature = critter_at( lp, true );
5813 if( creature != nullptr && u.sees( *creature ) ) {
5814 creature->draw( w_terrain, view_center, true );
5815 } else {
5816 m.drawsq( w_terrain, lp, drawsq_params().highlight( true ).center( view_center ) );
5817 }
5818 } else {
5819 std::string visibility_indicator;
5820 nc_color visibility_indicator_color = c_white;
5821 switch( visibility ) {
5822 case VIS_CLEAR:
5823 // Already handled by the outer if statement
5824 break;
5825 case VIS_BOOMER:
5826 case VIS_BOOMER_DARK:
5827 visibility_indicator = '#';
5828 visibility_indicator_color = c_pink;
5829 break;
5830 case VIS_DARK:
5831 visibility_indicator = '#';
5832 visibility_indicator_color = c_dark_gray;
5833 break;
5834 case VIS_LIT:
5835 visibility_indicator = '#';
5836 visibility_indicator_color = c_light_gray;
5837 break;
5838 case VIS_HIDDEN:
5839 visibility_indicator = 'x';
5840 visibility_indicator_color = c_white;
5841 break;
5842 }
5843
5844 const tripoint screen_pos = point( POSX, POSY ) + lp - view_center;
5845 mvwputch( w_terrain, screen_pos.xy(), visibility_indicator_color, visibility_indicator );
5846 }
5847 }
5848}
void draw_cursor(const tripoint &p)
Definition: animation.cpp:724
T * critter_at(const tripoint &p, bool allow_hallucination=false)
Returns the Creature at the given location.
Definition: game.cpp:4668
bool is_enabled()
Definition: live_view.cpp:75
virtual bool inbounds(const tripoint &p) const
Definition: map.cpp:7756
visibility_type get_visibility(lit_level ll, const visibility_variables &cache) const
Definition: map.cpp:5650
lit_level apparent_light_at(const tripoint &p, const visibility_variables &cache) const
Determine the visible light level for a tile, based on light_at for the tile, vision distance,...
Definition: lightmap.cpp:700
void drawsq(const catacurses::window &w, const tripoint &p, const drawsq_params &params) const
Draw the map tile at the given coordinate.
Definition: map.cpp:5828
#define c_dark_gray
Definition: color.h:20
#define c_pink
Definition: color.h:31
visibility_type
Definition: enums.h:57
@ VIS_CLEAR
Definition: enums.h:59
@ VIS_BOOMER
Definition: enums.h:61
@ VIS_DARK
Definition: enums.h:62
@ VIS_BOOMER_DARK
Definition: enums.h:63
@ VIS_HIDDEN
Definition: enums.h:58
@ VIS_LIT
Definition: enums.h:60
bool is_draw_tiles_mode()
Check whether we're in tile drawing mode.
Definition: output.cpp:2029
Draw parameters used by map::drawsq() and similar methods.
Definition: map.h:180

References map::apparent_light_at(), c_dark_gray, c_light_gray, c_pink, c_white, center, creature, critter_at(), draw_cursor(), map::drawsq(), map::get_visibility(), map::inbounds(), is_draw_tiles_mode(), live_view::is_enabled(), liveview, m, mvwputch(), Character::pos(), POSX, POSY, Character::sees(), u, player::view_offset, VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, VIS_LIT, w_terrain, and tripoint::xy().

Referenced by look_around().

◆ draw_minimap()

void game::draw_minimap ( )
private

Definition at line 3446 of file game.cpp.

3447{
3448
3449 // Draw the box
3450 werase( w_minimap );
3452
3453 const tripoint_abs_omt curs = u.global_omt_location();
3454 const point_abs_omt curs2( curs.xy() );
3456 bool drew_mission = targ == overmap::invalid_tripoint;
3457
3458 for( int i = -2; i <= 2; i++ ) {
3459 for( int j = -2; j <= 2; j++ ) {
3460 const point_abs_omt om( curs2 + point( i, j ) );
3461 nc_color ter_color;
3462 tripoint_abs_omt omp( om, get_levz() );
3463 std::string ter_sym;
3464 const bool seen = overmap_buffer.seen( omp );
3465 const bool vehicle_here = overmap_buffer.has_vehicle( omp );
3466 if( overmap_buffer.has_note( omp ) ) {
3467
3468 const std::string &note_text = overmap_buffer.note( omp );
3469
3470 ter_color = c_yellow;
3471 ter_sym = "N";
3472
3473 int symbolIndex = note_text.find( ':' );
3474 int colorIndex = note_text.find( ';' );
3475
3476 bool symbolFirst = symbolIndex < colorIndex;
3477
3478 if( colorIndex > -1 && symbolIndex > -1 ) {
3479 if( symbolFirst ) {
3480 if( colorIndex > 4 ) {
3481 colorIndex = -1;
3482 }
3483 if( symbolIndex > 1 ) {
3484 symbolIndex = -1;
3485 colorIndex = -1;
3486 }
3487 } else {
3488 if( symbolIndex > 4 ) {
3489 symbolIndex = -1;
3490 }
3491 if( colorIndex > 2 ) {
3492 colorIndex = -1;
3493 }
3494 }
3495 } else if( colorIndex > 2 ) {
3496 colorIndex = -1;
3497 } else if( symbolIndex > 1 ) {
3498 symbolIndex = -1;
3499 }
3500
3501 if( symbolIndex > -1 ) {
3502 int symbolStart = 0;
3503 if( colorIndex > -1 && !symbolFirst ) {
3504 symbolStart = colorIndex + 1;
3505 }
3506 ter_sym = note_text.substr( symbolStart, symbolIndex - symbolStart ).c_str()[0];
3507 }
3508
3509 if( colorIndex > -1 ) {
3510
3511 int colorStart = 0;
3512
3513 if( symbolIndex > -1 && symbolFirst ) {
3514 colorStart = symbolIndex + 1;
3515 }
3516
3517 std::string sym = note_text.substr( colorStart, colorIndex - colorStart );
3518
3519 if( sym.length() == 2 ) {
3520 if( sym == "br" ) {
3521 ter_color = c_brown;
3522 } else if( sym == "lg" ) {
3523 ter_color = c_light_gray;
3524 } else if( sym == "dg" ) {
3525 ter_color = c_dark_gray;
3526 }
3527 } else {
3528 char colorID = sym.c_str()[0];
3529 if( colorID == 'r' ) {
3530 ter_color = c_light_red;
3531 } else if( colorID == 'R' ) {
3532 ter_color = c_red;
3533 } else if( colorID == 'g' ) {
3534 ter_color = c_light_green;
3535 } else if( colorID == 'G' ) {
3536 ter_color = c_green;
3537 } else if( colorID == 'b' ) {
3538 ter_color = c_light_blue;
3539 } else if( colorID == 'B' ) {
3540 ter_color = c_blue;
3541 } else if( colorID == 'W' ) {
3542 ter_color = c_white;
3543 } else if( colorID == 'C' ) {
3544 ter_color = c_cyan;
3545 } else if( colorID == 'c' ) {
3546 ter_color = c_light_cyan;
3547 } else if( colorID == 'P' ) {
3548 ter_color = c_pink;
3549 } else if( colorID == 'm' ) {
3550 ter_color = c_magenta;
3551 }
3552 }
3553 }
3554 } else if( !seen ) {
3555 ter_sym = " ";
3556 ter_color = c_black;
3557 } else if( vehicle_here ) {
3558 ter_color = c_cyan;
3559 ter_sym = "c";
3560 } else {
3561 const oter_id &cur_ter = overmap_buffer.ter( omp );
3562 ter_sym = cur_ter->get_symbol();
3563 if( overmap_buffer.is_explored( omp ) ) {
3564 ter_color = c_dark_gray;
3565 } else {
3566 ter_color = cur_ter->get_color();
3567 }
3568 }
3569 if( !drew_mission && targ.xy() == omp.xy() ) {
3570 // If there is a mission target, and it's not on the same
3571 // overmap terrain as the player character, mark it.
3572 // TODO: Inform player if the mission is above or below
3573 drew_mission = true;
3574 if( i != 0 || j != 0 ) {
3575 ter_color = red_background( ter_color );
3576 }
3577 }
3578 if( i == 0 && j == 0 ) {
3579 mvwputch_hi( w_minimap, point( 3, 3 ), ter_color, ter_sym );
3580 } else {
3581 mvwputch( w_minimap, point( 3 + i, 3 + j ), ter_color, ter_sym );
3582 }
3583 }
3584 }
3585
3586 // Print arrow to mission if we have one!
3587 if( !drew_mission ) {
3588 double slope = curs2.x() != targ.x() ?
3589 static_cast<double>( targ.y() - curs2.y() ) / ( targ.x() - curs2.x() ) : 4;
3590
3591 if( curs2.x() == targ.x() || std::fabs( slope ) > 3.5 ) { // Vertical slope
3592 if( targ.y() > curs2.y() ) {
3593 mvwputch( w_minimap, point( 3, 6 ), c_red, "*" );
3594 } else {
3595 mvwputch( w_minimap, point( 3, 0 ), c_red, "*" );
3596 }
3597 } else {
3598 int arrowx = -1;
3599 int arrowy = -1;
3600 if( std::fabs( slope ) >= 1. ) { // y diff is bigger!
3601 arrowy = targ.y() > curs2.y() ? 6 : 0;
3602 arrowx =
3603 static_cast<int>( 3 + 3 * ( targ.y() > curs2.y() ? slope : ( 0 - slope ) ) );
3604 if( arrowx < 0 ) {
3605 arrowx = 0;
3606 }
3607 if( arrowx > 6 ) {
3608 arrowx = 6;
3609 }
3610 } else {
3611 arrowx = targ.x() > curs2.x() ? 6 : 0;
3612 arrowy = static_cast<int>( 3 + 3 * ( targ.x() > curs2.x() ? slope : -slope ) );
3613 if( arrowy < 0 ) {
3614 arrowy = 0;
3615 }
3616 if( arrowy > 6 ) {
3617 arrowy = 6;
3618 }
3619 }
3620 char glyph = '*';
3621 if( targ.z() > u.posz() ) {
3622 glyph = '^';
3623 } else if( targ.z() < u.posz() ) {
3624 glyph = 'v';
3625 }
3626
3627 mvwputch( w_minimap, point( arrowx, arrowy ), c_red, glyph );
3628 }
3629 }
3630
3631 const int sight_points = g->u.overmap_sight_range( g->light_level( g->u.posz() ) );
3632 for( int i = -3; i <= 3; i++ ) {
3633 for( int j = -3; j <= 3; j++ ) {
3634 if( i > -3 && i < 3 && j > -3 && j < 3 ) {
3635 continue; // only do hordes on the border, skip inner map
3636 }
3637 const tripoint_abs_omt omp( curs2 + point( i, j ), get_levz() );
3639 if( overmap_buffer.seen( omp )
3640 && g->u.overmap_los( omp, sight_points ) ) {
3641 mvwputch( w_minimap, point( i + 3, j + 3 ), c_green,
3642 overmap_buffer.get_horde_size( omp ) > HORDE_VISIBILITY_SIZE * 2 ? 'Z' : 'z' );
3643 }
3644 }
3645 }
3646 }
3647
3649}
tripoint_abs_omt get_active_mission_target() const
Returns the target of the active mission or overmap::invalid_tripoint if there is no active mission.
Definition: avatar.cpp:203
constexpr auto & x()
Definition: coordinates.h:118
constexpr auto & z()
Definition: coordinates.h:133
constexpr auto & y()
Definition: coordinates.h:124
constexpr auto xy() const
Definition: coordinates.h:130
static constexpr tripoint_abs_omt invalid_tripoint
Dummy value, used to indicate that a point returned by a function is invalid.
Definition: overmap.h:260
bool seen(const tripoint_abs_omt &p)
const std::string & note(const tripoint_abs_omt &p)
int get_horde_size(const tripoint_abs_omt &p)
bool is_explored(const tripoint_abs_omt &p)
const oter_id & ter(const tripoint_abs_omt &p)
Returns the overmap terrain at the given OMT coordinates.
bool has_note(const tripoint_abs_omt &p)
Uses global overmap terrain coordinates.
bool has_vehicle(const tripoint_abs_omt &p)
nc_color red_background(const nc_color &c)
Definition: color.cpp:515
#define c_blue
Definition: color.h:23
#define c_black
Definition: color.h:17
#define c_light_blue
Definition: color.h:29
#define c_yellow
Definition: color.h:32
#define c_light_cyan
Definition: color.h:30
#define c_cyan
Definition: color.h:24
#define c_light_red
Definition: color.h:27
static constexpr int HORDE_VISIBILITY_SIZE
constexpr scale om
Definition: coordinates.h:34
void mvwputch_hi(const catacurses::window &w, const point &p, nc_color FG, int ch)
Definition: output.cpp:508
std::string get_symbol(const bool from_land_use_code=false) const
Definition: omdata.h:209
nc_color get_color(const bool from_land_use_code=false) const
Definition: omdata.h:217

References c_black, c_blue, c_brown, c_cyan, c_dark_gray, c_green, c_light_blue, c_light_cyan, c_light_gray, c_light_green, c_light_red, c_magenta, c_pink, c_red, c_white, c_yellow, draw_border(), units::fabs(), g, avatar::get_active_mission_target(), oter_t::get_color(), overmapbuffer::get_horde_size(), get_levz(), oter_t::get_symbol(), Character::global_omt_location(), overmapbuffer::has_note(), overmapbuffer::has_vehicle(), HORDE_VISIBILITY_SIZE, overmap::invalid_tripoint, overmapbuffer::is_explored(), mvwputch(), mvwputch_hi(), overmapbuffer::note(), coords::om, overmap_buffer, Character::posz(), red_background(), overmapbuffer::seen(), overmapbuffer::ter(), u, w_minimap, catacurses::werase(), catacurses::wnoutrefresh(), coords::coord_point< Point, Origin, Scale >::x(), coords::coord_point< Point, Origin, Scale >::xy(), coords::coord_point< Point, Origin, Scale >::y(), and coords::coord_point< Point, Origin, Scale >::z().

◆ draw_monster_override()

void game::draw_monster_override ( const tripoint p,
const mtype_id id,
int  count,
bool  more,
Creature::Attitude  att 
)

Definition at line 977 of file animation.cpp.

979{
980}

◆ draw_panels()

void game::draw_panels ( bool  force_draw = false)

Definition at line 3272 of file game.cpp.

3273{
3274 static int previous_turn = -1;
3275 const int current_turn = to_turns<int>( calendar::turn - calendar::turn_zero );
3276 const bool draw_this_turn = current_turn > previous_turn || force_draw;
3277 auto &mgr = panel_manager::get_manager();
3278 int y = 0;
3279 const bool sidebar_right = get_option<std::string>( "SIDEBAR_POSITION" ) == "right";
3280 int spacer = get_option<bool>( "SIDEBAR_SPACERS" ) ? 1 : 0;
3281 int log_height = 0;
3282 for( const window_panel &panel : mgr.get_current_layout() ) {
3283 if( panel.get_height() != -2 && panel.toggle && panel.render() ) {
3284 log_height += panel.get_height() + spacer;
3285 }
3286 }
3287 log_height = std::max( TERMY - log_height, 3 );
3288 for( const window_panel &panel : mgr.get_current_layout() ) {
3289 if( panel.render() ) {
3290 // height clamped to window height.
3291 int h = std::min( panel.get_height(), TERMY - y );
3292 if( h == -2 ) {
3293 h = log_height;
3294 }
3295 h += spacer;
3296 if( panel.toggle && panel.render() && h > 0 ) {
3297 if( panel.always_draw || draw_this_turn ) {
3298 panel.draw( u, catacurses::newwin( h, panel.get_width(),
3299 point( sidebar_right ? TERMX - panel.get_width() : 0, y ) ) );
3300 }
3301 if( show_panel_adm ) {
3302 const std::string panel_name = _( panel.get_name() );
3303 const int panel_name_width = utf8_width( panel_name );
3304 auto label = catacurses::newwin( 1, panel_name_width, point( sidebar_right ?
3305 TERMX - panel.get_width() - panel_name_width - 1 : panel.get_width() + 1, y ) );
3306 werase( label );
3307 mvwprintz( label, point_zero, c_light_red, panel_name );
3309 label = catacurses::newwin( h, 1,
3310 point( sidebar_right ? TERMX - panel.get_width() - 1 : panel.get_width(), y ) );
3311 werase( label );
3312 if( h == 1 ) {
3314 } else {
3316 for( int i = 1; i < h - 1; i++ ) {
3318 }
3319 mvwputch( label, point( 0, h - 1 ), c_light_red, sidebar_right ? LINE_XXOO : LINE_XOOX );
3320 }
3322 }
3323 y += h;
3324 }
3325 }
3326 }
3327 previous_turn = current_turn;
3328}
bool show_panel_adm
Definition: game.h:1040
const time_point turn_zero
Represents time point 0.
Definition: calendar.cpp:26
#define LINE_XOXO
Definition: output.h:39
#define LINE_OXOX
Definition: output.h:40
#define LINE_OXXX
Definition: output.h:48
#define LINE_XOOX
Definition: output.h:44
#define LINE_XXOO
Definition: output.h:41
Struct used for storing labels (easier to json opposed to a std::map<point, std::string>)
Definition: vehicle.h:578

References _, c_light_red, panel_manager::get_manager(), LINE_OXOX, LINE_OXXX, LINE_XOOX, LINE_XOXO, LINE_XXOO, mvwprintz(), mvwputch(), catacurses::newwin(), point_zero, show_panel_adm, TERMX, TERMY, calendar::turn, calendar::turn_zero, u, utf8_width(), catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by draw().

◆ draw_pixel_minimap()

void game::draw_pixel_minimap ( const catacurses::window w)

Definition at line 3330 of file game.cpp.

3331{
3332 w_pixel_minimap = w;
3333}

References w_pixel_minimap.

◆ draw_radiation_override()

void game::draw_radiation_override ( const tripoint p,
int  rad 
)

Definition at line 854 of file animation.cpp.

855{
856}

◆ draw_sct()

void game::draw_sct ( )

Definition at line 805 of file animation.cpp.

806{
807 draw_sct_curses( *this );
808}
void draw_sct_curses(const game &g)
Definition: animation.cpp:772

References anonymous_namespace{animation.cpp}::draw_sct_curses().

Referenced by get_player_input().

◆ draw_ter() [1/2]

void game::draw_ter ( bool  draw_sounds = true)

Definition at line 3386 of file game.cpp.

3387{
3389 draw_sounds );
3390}
bool is_looking
Definition: game.h:250

References draw_ter(), is_looking, Character::pos(), u, and player::view_offset.

Referenced by draw(), and draw_ter().

◆ draw_ter() [2/2]

void game::draw_ter ( const tripoint center,
bool  looking = false,
bool  draw_sounds = true 
)

Definition at line 3392 of file game.cpp.

3393{
3395
3396 m.draw( w_terrain, center );
3397
3398 if( draw_sounds ) {
3400 }
3401
3402 for( Creature &critter : all_creatures() ) {
3403 draw_critter( critter, center );
3404 }
3405
3406 if( !destination_preview.empty() && u.view_offset.z == 0 ) {
3407 // Draw auto-move preview trail
3408 const tripoint &final_destination = destination_preview.back();
3409 tripoint line_center = u.pos() + u.view_offset;
3410 draw_line( final_destination, line_center, destination_preview, true );
3411 mvwputch( w_terrain, final_destination.xy() - u.view_offset.xy() + point( POSX - u.posx(),
3412 POSY - u.posy() ), c_white, 'X' );
3413 }
3414
3415 if( u.controlling_vehicle && !looking ) {
3416 draw_veh_dir_indicator( false );
3417 draw_veh_dir_indicator( true );
3418 }
3419 // Place the cursor over the player as is expected by screen readers.
3420 wmove( w_terrain, -center.xy() + g->u.pos().xy() + point( POSX, POSY ) );
3421}
int posx() const override
Definition: character.h:779
int posy() const override
Definition: character.h:782
void draw_critter(const Creature &critter, const tripoint &center)
Definition: game.cpp:3368
Creature_range all_creatures()
Returns an anonymous range that contains all creatures.
Definition: game.cpp:12083
std::vector< tripoint > destination_preview
Definition: game.h:1092
void draw_veh_dir_indicator(bool next)
Definition: game.cpp:3438
void draw_line(const tripoint &p, const tripoint &center_point, const std::vector< tripoint > &points, bool noreveal=false)
Definition: animation.cpp:677
void draw(const catacurses::window &w, const tripoint &center)
Draw a visible part of the map into w.
Definition: map.cpp:5700
static void draw_footsteps(const catacurses::window &window, const tripoint &offset)
Definition: game.cpp:3058
void wmove(const window &win, const point &p)
Definition: ncurses_def.cpp:98

References all_creatures(), c_white, center, Character::controlling_vehicle, destination_preview, map::draw(), draw_critter(), draw_footsteps(), draw_line(), draw_veh_dir_indicator(), g, m, mvwputch(), Character::pos(), Character::posx(), POSX, Character::posy(), POSY, ter_view_p, u, player::view_offset, w_terrain, catacurses::wmove(), tripoint::xy(), and tripoint::z.

◆ draw_terrain_override()

void game::draw_terrain_override ( const tripoint p,
const ter_id id 
)

Definition at line 867 of file animation.cpp.

868{
869}

◆ draw_trail_to_square()

void game::draw_trail_to_square ( const tripoint t,
bool  bDrawX 
)

Definition at line 7107 of file game.cpp.

7108{
7109 ::draw_trail( u.pos(), u.pos() + t, bDrawX );
7110}
static void draw_trail(const tripoint &start, const tripoint &end, bool bDrawX)
Definition: game.cpp:7077

References draw_trail(), Character::pos(), and u.

◆ draw_trap_override()

void game::draw_trap_override ( const tripoint p,
const trap_id id 
)

Definition at line 906 of file animation.cpp.

907{
908}

◆ draw_veh_dir_indicator()

void game::draw_veh_dir_indicator ( bool  next)

Definition at line 3438 of file game.cpp.

3439{
3440 if( const cata::optional<tripoint> indicator_offset = get_veh_dir_indicator_location( next ) ) {
3441 auto col = next ? c_white : c_dark_gray;
3442 mvwputch( w_terrain, indicator_offset->xy() - u.view_offset.xy() + point( POSX, POSY ), col, 'X' );
3443 }
3444}
cata::optional< tripoint > get_veh_dir_indicator_location(bool next) const
Returns the location where the indicator should go relative to the reality bubble,...
Definition: game.cpp:3423

References c_dark_gray, c_white, get_veh_dir_indicator_location(), mvwputch(), POSX, POSY, u, player::view_offset, w_terrain, and tripoint::xy().

Referenced by draw_ter().

◆ draw_vpart_override()

void game::draw_vpart_override ( const tripoint p,
const vpart_id id,
int  part_mod,
units::angle  veh_dir,
bool  hilite,
const point mount 
)

Definition at line 949 of file animation.cpp.

951{
952}

◆ draw_weather()

void game::draw_weather ( const weather_printable wPrint)

Definition at line 764 of file animation.cpp.

765{
767}
void draw_weather_curses(const catacurses::window &win, const weather_printable &w)
Definition: animation.cpp:745

References anonymous_namespace{animation.cpp}::draw_weather_curses(), and w_terrain.

Referenced by get_player_input().

◆ draw_zones()

void game::draw_zones ( const tripoint start,
const tripoint end,
const tripoint offset 
)

Definition at line 840 of file animation.cpp.

841{
842 draw_zones_curses( w_terrain, start, end, offset );
843}
void draw_zones_curses(const catacurses::window &w, const tripoint &start, const tripoint &end, const tripoint &offset)
Definition: animation.cpp:813

References anonymous_namespace{animation.cpp}::draw_zones_curses(), and w_terrain.

◆ drop()

void game::drop ( )
private

Definition at line 8149 of file game.cpp.

8150{
8152}
void drop(item_location loc, const tripoint &where)
Drops an item to the specified location.
Definition: character.cpp:2505
drop_locations multidrop(player &p)
Select items to drop.

References Character::drop(), game_menus::inv::multidrop(), Character::pos(), and u.

Referenced by handle_action().

◆ drop_in_direction()

void game::drop_in_direction ( )
private

Definition at line 8154 of file game.cpp.

8155{
8156 if( const cata::optional<tripoint> pnt = choose_adjacent( _( "Drop where?" ) ) ) {
8157 u.drop( game_menus::inv::multidrop( u ), *pnt );
8158 }
8159}

References _, choose_adjacent(), Character::drop(), game_menus::inv::multidrop(), and u.

Referenced by handle_action().

◆ dump_stats()

bool game::dump_stats ( const std::string &  what,
dump_mode  mode,
const std::vector< std::string > &  opts 
)

write statistics to stdout and

Returns
true if successful

Definition at line 37 of file dump.cpp.

39{
40 try {
41 loading_ui ui( false );
43 load_packs( _( "Loading content packs" ), { mod_id( "dda" ) }, ui );
45 } catch( const std::exception &err ) {
46 std::cerr << "Error loading data from json: " << err.what() << std::endl;
47 return false;
48 }
49
50 std::vector<std::string> header;
51 std::vector<std::vector<std::string>> rows;
52
53 int scol = 0; // sorting column
54
55 std::map<std::string, standard_npc> test_npcs;
56 test_npcs[ "S1" ] = standard_npc( "S1", { 0, 0, 2 }, { "gloves_survivor", "mask_lsurvivor" },
57 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
58 test_npcs[ "S2" ] = standard_npc( "S2", { 0, 0, 3 }, { "gloves_fingerless", "sunglasses" },
59 4, 8, 8, 8, 10 /* PER 10 */ );
60 test_npcs[ "S3" ] = standard_npc( "S3", { 0, 0, 4 }, { "gloves_plate", "helmet_plate" },
61 4, 10, 8, 8, 8 /* STAT 10 */ );
62 test_npcs[ "S4" ] = standard_npc( "S4", { 0, 0, 5 }, {}, 0, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
63 test_npcs[ "S5" ] = standard_npc( "S5", { 0, 0, 6 }, {}, 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
64 test_npcs[ "S6" ] = standard_npc( "S6", { 0, 0, 7 }, { "gloves_hsurvivor", "mask_hsurvivor" },
65 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
66
67 std::map<std::string, item> test_items;
68 test_items[ "G1" ] = item( "glock_19" ).ammo_set( itype_id( "9mm" ) );
69 test_items[ "G2" ] = item( "hk_mp5" ).ammo_set( itype_id( "9mm" ) );
70 test_items[ "G3" ] = item( "ar15" ).ammo_set( itype_id( "223" ) );
71 test_items[ "G4" ] = item( "remington_700" ).ammo_set( itype_id( "270" ) );
72 test_items[ "G4" ].put_in( item( "rifle_scope" ) );
73
74 if( what == "AMMO" ) {
75 header = {
76 "Name", "Ammo", "Volume", "Weight", "Stack",
77 "Range", "Dispersion", "Recoil", "Damage", "Pierce", "Damage multiplier"
78 };
79 auto dump = [&rows]( const item & obj ) {
80 std::vector<std::string> r;
81 r.push_back( obj.tname( 1, false ) );
82 r.push_back( obj.ammo_type().str() );
83 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
84 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
85 r.push_back( std::to_string( obj.type->stack_size ) );
86 r.push_back( std::to_string( obj.type->ammo->range ) );
87 r.push_back( std::to_string( obj.type->ammo->dispersion ) );
88 r.push_back( std::to_string( obj.type->ammo->recoil ) );
89 damage_instance damage = obj.type->ammo->damage;
90 r.push_back( std::to_string( damage.total_damage() ) );
91 r.push_back( std::to_string( damage.empty() ? 0 : ( *damage.begin() ).res_pen ) );
92 rows.push_back( r );
93 };
94 for( const itype *e : item_controller->all() ) {
95 if( e->ammo ) {
96 dump( item( e, calendar::turn, item::solitary_tag {} ) );
97 }
98 }
99
100 } else if( what == "ARMOR" ) {
101 header = {
102 "Name", "Encumber (fit)", "Warmth", "Weight", "Storage", "Coverage", "Bash", "Cut", "Bullet", "Acid", "Fire"
103 };
104 auto dump = [&rows]( const item & obj ) {
105 std::vector<std::string> r;
106 r.push_back( obj.tname( 1, false ) );
107 r.push_back( std::to_string( obj.get_encumber( g->u ) ) );
108 r.push_back( std::to_string( obj.get_warmth() ) );
109 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
110 r.push_back( std::to_string( obj.get_storage() / units::legacy_volume_factor ) );
111 r.push_back( std::to_string( obj.get_coverage() ) );
112 r.push_back( std::to_string( obj.bash_resist() ) );
113 r.push_back( std::to_string( obj.cut_resist() ) );
114 r.push_back( std::to_string( obj.bullet_resist() ) );
115 r.push_back( std::to_string( obj.acid_resist() ) );
116 r.push_back( std::to_string( obj.fire_resist() ) );
117 rows.push_back( r );
118 };
119
120 body_part bp = opts.empty() ? num_bp : get_body_part_token( opts.front() );
121
122 for( const itype *e : item_controller->all() ) {
123 if( e->armor ) {
124 item obj( e );
125 if( bp == num_bp || obj.covers( bp ) ) {
126 if( obj.has_flag( flag_VARSIZE ) ) {
127 obj.set_flag( "FIT" );
128 }
129 dump( obj );
130 }
131 }
132 }
133
134 } else if( what == "EDIBLE" ) {
135 header = {
136 "Name", "Volume", "Weight", "Stack", "Calories", "Quench", "Healthy"
137 };
138 for( const auto &v : vitamin::all() ) {
139 header.push_back( v.second.name() );
140 }
141 auto dump = [&rows]( const item & obj ) {
142 std::vector<std::string> r;
143 r.push_back( obj.tname( 1, false ) );
144 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
145 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
146 r.push_back( std::to_string( obj.type->stack_size ) );
147 r.push_back( std::to_string( obj.get_comestible()->default_nutrition.kcal ) );
148 r.push_back( std::to_string( obj.get_comestible()->quench ) );
149 r.push_back( std::to_string( obj.get_comestible()->healthy ) );
150 auto vits = obj.get_comestible()->default_nutrition.vitamins;
151 for( const auto &v : vitamin::all() ) {
152 r.push_back( std::to_string( vits[ v.first ] ) );
153 }
154 rows.push_back( r );
155 };
156
157 for( const itype *e : item_controller->all() ) {
159
160 if( food.is_food() && g->u.can_eat( food ).success() ) {
161 dump( food );
162 }
163 }
164
165 } else if( what == "GUN" ) {
166 header = {
167 "Name", "Ammo", "Volume", "Weight", "Capacity",
168 "Range", "Dispersion", "Effective recoil", "Damage", "Pierce",
169 "Aim time", "Effective range", "Snapshot range", "Max range"
170 };
171
172 std::set<std::string> locations;
173 for( const itype *e : item_controller->all() ) {
174 if( e->gun ) {
175 std::transform( e->gun->valid_mod_locations.begin(),
176 e->gun->valid_mod_locations.end(),
177 std::inserter( locations, locations.begin() ),
178 []( const std::pair<gunmod_location, int> &q ) {
179 return q.first.name();
180 } );
181 }
182 }
183 for( const auto &e : locations ) {
184 header.push_back( e );
185 }
186
187 auto dump = [&rows, &locations]( const standard_npc & who, const item & obj ) {
188 std::vector<std::string> r;
189 r.push_back( obj.tname( 1, false ) );
190 r.push_back( !obj.ammo_types().empty() ? enumerate_as_string( obj.ammo_types().begin(),
191 obj.ammo_types().end(), []( const ammotype & at ) {
192 return at.str();
194 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
195 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
196 r.push_back( std::to_string( obj.ammo_capacity() ) );
197 r.push_back( std::to_string( obj.gun_range() ) );
198 r.push_back( std::to_string( obj.gun_dispersion() ) );
199 r.push_back( std::to_string( obj.gun_recoil() ) );
200 damage_instance damage = obj.gun_damage();
201 r.push_back( std::to_string( damage.total_damage() ) );
202 r.push_back( std::to_string( damage.empty() ? 0 : ( *damage.begin() ).res_pen ) );
203
204 r.push_back( std::to_string( who.gun_engagement_moves( obj ) ) );
205
206 for( const auto &e : locations ) {
207 const auto &vml = obj.type->gun->valid_mod_locations;
208 const auto iter = vml.find( e );
209 r.push_back( std::to_string( iter != vml.end() ? iter->second : 0 ) );
210 }
211 rows.push_back( r );
212 };
213 for( const itype *e : item_controller->all() ) {
214 if( e->gun ) {
215 item gun( e );
216 if( !gun.magazine_integral() ) {
217 gun.put_in( item( gun.magazine_default() ) );
218 }
219 gun.ammo_set( gun.ammo_default( false ), gun.ammo_capacity() );
220
221 dump( test_npcs[ "S1" ], gun );
222
223 if( gun.type->gun->barrel_length > 0_ml ) {
224 gun.put_in( item( "barrel_small" ) );
225 dump( test_npcs[ "S1" ], gun );
226 }
227 }
228 }
229
230 } else if( what == "RECIPE" ) {
231
232 // optionally filter recipes to include only those using specified skills
233 recipe_subset dict;
234 for( const auto &r : recipe_dict ) {
235 if( opts.empty() || std::any_of( opts.begin(), opts.end(), [&r]( const std::string & s ) {
236 if( r.second.skill_used == skill_id( s ) && r.second.difficulty > 0 ) {
237 return true;
238 }
239 const auto iter = r.second.required_skills.find( skill_id( s ) );
240 return iter != r.second.required_skills.end() && iter->second > 0;
241 } ) ) {
242 dict.include( &r.second );
243 }
244 }
245
246 // only consider skills that are required by at least one recipe
247 std::vector<Skill> sk;
248 std::copy_if( Skill::skills.begin(), Skill::skills.end(),
249 std::back_inserter( sk ), [&dict]( const Skill & s ) {
250 return std::any_of( dict.begin(), dict.end(), [&s]( const recipe * r ) {
251 return r->skill_used == s.ident() ||
252 r->required_skills.find( s.ident() ) != r->required_skills.end();
253 } );
254 } );
255
256 header = { "Result" };
257
258 for( const auto &e : sk ) {
259 header.push_back( e.ident().str() );
260 }
261
262 for( const recipe *e : dict ) {
263 std::vector<std::string> r;
264 r.push_back( e->result_name() );
265 for( const auto &s : sk ) {
266 if( e->skill_used == s.ident() ) {
267 r.push_back( std::to_string( e->difficulty ) );
268 } else {
269 auto iter = e->required_skills.find( s.ident() );
270 r.push_back( std::to_string( iter != e->required_skills.end() ? iter->second : 0 ) );
271 }
272 }
273 rows.push_back( r );
274 }
275
276 } else if( what == "VEHICLE" ) {
277 header = {
278 "Name", "Weight (empty)", "Weight (fueled)",
279 "Max velocity (mph)", "Safe velocity (mph)", "Acceleration (mph/turn)",
280 "Aerodynamics coeff", "Rolling coeff", "Static Drag", "Offroad %"
281 };
282 auto dump = [&rows]( const vproto_id & obj ) {
283 vehicle veh_empty( obj, 0, 0 );
284 vehicle veh_fueled( obj, 100, 0 );
285
286 std::vector<std::string> r;
287 r.push_back( veh_empty.name );
288 r.push_back( std::to_string( to_kilogram( veh_empty.total_mass() ) ) );
289 r.push_back( std::to_string( to_kilogram( veh_fueled.total_mass() ) ) );
290 r.push_back( std::to_string( veh_fueled.max_velocity() / 100 ) );
291 r.push_back( std::to_string( veh_fueled.safe_velocity() / 100 ) );
292 r.push_back( std::to_string( veh_fueled.acceleration() / 100 ) );
293 r.push_back( std::to_string( veh_fueled.coeff_air_drag() ) );
294 r.push_back( std::to_string( veh_fueled.coeff_rolling_drag() ) );
295 r.push_back( std::to_string( veh_fueled.static_drag( false ) ) );
296 r.push_back( std::to_string( static_cast<int>( 50 *
297 veh_fueled.k_traction( veh_fueled.wheel_area() ) ) ) );
298 rows.push_back( r );
299 };
300 for( auto &e : vehicle_prototype::get_all() ) {
301 dump( e );
302 }
303
304 } else if( what == "VPART" ) {
305 header = {
306 "Name", "Location", "Weight", "Size"
307 };
308 auto dump = [&rows]( const vpart_info & obj ) {
309 std::vector<std::string> r;
310 r.push_back( obj.name() );
311 r.push_back( obj.location );
312 int w = std::ceil( to_gram( item( obj.item ).weight() ) / 1000.0 );
313 r.push_back( std::to_string( w ) );
314 r.push_back( std::to_string( obj.size / units::legacy_volume_factor ) );
315 rows.push_back( r );
316 };
317 for( const auto &e : vpart_info::all() ) {
318 dump( e.second );
319 }
320
321 } else {
322 std::cerr << "unknown argument: " << what << std::endl;
323 return false;
324 }
325
326 rows.erase( std::remove_if( rows.begin(), rows.end(), []( const std::vector<std::string> &e ) {
327 return e.empty();
328 } ), rows.end() );
329
330 if( scol >= 0 ) {
331 std::sort( rows.begin(), rows.end(), [&scol]( const std::vector<std::string> &lhs,
332 const std::vector<std::string> &rhs ) {
333 return localized_compare( lhs[ scol ], rhs[ scol ] );
334 } );
335 }
336
337 rows.erase( std::unique( rows.begin(), rows.end() ), rows.end() );
338
339 switch( mode ) {
340 case dump_mode::TSV:
341 rows.insert( rows.begin(), header );
342 for( const auto &r : rows ) {
343 // NOLINTNEXTLINE(cata-text-style): using tab to align the output
344 std::copy( r.begin(), r.end() - 1, std::ostream_iterator<std::string>( std::cout, "\t" ) );
345 std::cout << r.back() << "\n";
346 }
347 break;
348
349 case dump_mode::HTML:
350 std::cout << "<table>";
351
352 std::cout << "<thead>";
353 std::cout << "<tr>";
354 for( const auto &col : header ) {
355 std::cout << "<th>" << col << "</th>";
356 }
357 std::cout << "</tr>";
358 std::cout << "</thead>";
359
360 std::cout << "<tdata>";
361 for( const auto &r : rows ) {
362 std::cout << "<tr>";
363 for( const auto &col : r ) {
364 std::cout << "<td>" << col << "</td>";
365 }
366 std::cout << "</tr>";
367 }
368 std::cout << "</tdata>";
369
370 std::cout << "</table>";
371 break;
372 }
373
374 return true;
375}
body_part get_body_part_token(const std::string &id)
Returns the matching body_part token from the corresponding body_part string.
Definition: bodypart.cpp:180
body_part
Definition: bodypart.h:39
std::string to_string(const time_duration &d)
Returns a string showing a duration.
Definition: calendar.cpp:327
Definition: skill.h:33
static std::vector< Skill > skills
Definition: skill.h:49
const skill_id & ident() const
Definition: skill.h:65
bool load_packs(const std::string &msg, const std::vector< mod_id > &packs, loading_ui &ui)
Load content packs.
Definition: game.cpp:2763
units::mass weight(bool include_contents=true, bool integral=false) const
Definition: item.cpp:4865
void put_in(const item &payload)
Puts the given item into this one, no checks are performed.
Definition: item.cpp:990
item & ammo_set(const itype_id &ammo, int qty=-1)
Filter setting the ammo for this instance Any existing ammo is removed.
Definition: item.cpp:590
std::set< constrecipe * >::const_iterator begin() const
std::set< constrecipe * >::const_iterator end() const
void include(const recipe *r, int custom_difficulty=-1)
Include a recipe to the subset.
Definition: recipe.h:35
An NPC with standard stats.
Definition: npc.h:1394
static const std::map< vitamin_id, vitamin > & all()
Get all currently loaded vitamins.
Definition: vitamin.cpp:98
static const std::map< vpart_id, vpart_info > & all()
Definition: veh_type.cpp:694
static const std::string flag_VARSIZE("VARSIZE")
std::unique_ptr< Item_factory > item_controller
void transform(player &p, const tripoint &pos)
Transform the examined object into the object specified by its transforms_into property.
Definition: iexamine.cpp:1641
static constexpr volume legacy_volume_factor
Definition: units_volume.h:50
constexpr value_type to_gram(const quantity< value_type, mass_in_milligram_tag > &v)
Definition: units_mass.h:67
constexpr value_type to_kilogram(const quantity< value_type, mass_in_milligram_tag > &v)
Definition: units_mass.h:73
std::string enumerate_as_string(const _Container &values, enumeration_conjunction conj=enumeration_conjunction::and_)
Definition: output.h:680
recipe_dictionary recipe_dict
float total_damage() const
Definition: damage.cpp:75
std::vector< damage_unit >::iterator begin()
Definition: damage.cpp:120
bool empty() const
Definition: damage.cpp:88
Default (or randomized) charges except if counted by charges then only one charge.
Definition: item.h:197
Definition: itype.h:836
static std::vector< vproto_id > get_all()
Definition: veh_type.cpp:1157
string_id< MOD_INFORMATION > mod_id
Definition: type_id.h:98

References _, vitamin::all(), item::ammo_capacity(), item::ammo_default(), item::ammo_set(), damage_instance::begin(), item::covers(), damage_instance::empty(), enumerate_as_string(), DynamicDataLoader::finalize_loaded_data(), flag_VARSIZE(), g, get_body_part_token(), DynamicDataLoader::get_instance(), itype::gun, item::has_flag(), Skill::ident(), recipe_subset::include(), item_controller, itype_id, units::legacy_volume_factor, load_core_data(), load_packs(), anonymous_namespace{overmap_location.cpp}::locations, item::magazine_default(), item::magazine_integral(), none, num_bp, item::put_in(), recipe_dict, item::set_flag(), Skill::skills, units::to_gram(), to_string(), damage_instance::total_damage(), iexamine::transform(), calendar::turn, and item::type.

◆ events()

event_bus & game::events ( )

Definition at line 2873 of file game.cpp.

2874{
2875 return *event_bus_ptr;
2876}
pimpl< event_bus > event_bus_ptr
Definition: game.h:979

References event_bus_ptr.

Referenced by cleanup_at_end(), and game().

◆ exam_vehicle()

void game::exam_vehicle ( vehicle veh,
const point cp = point_zero 
)

open vehicle interaction screen

Definition at line 5106 of file game.cpp.

5107{
5108 if( veh.magic ) {
5109 add_msg( m_info, _( "This is your %s" ), veh.name );
5110 return;
5111 }
5112 auto act = veh_interact::run( veh, c );
5113 if( act ) {
5114 u.moves = 0;
5116 }
5117}
static player_activity run(vehicle &veh, const point &p)
bool magic
Definition: vehicle.h:1866
constexpr double c
Definition: magic.cpp:1032
activity_id act
Definition: sounds.cpp:75

References _, act, add_msg(), Character::assign_activity(), c, m_info, vehicle::magic, Creature::moves, vehicle::name, veh_interact::run(), and u.

◆ examine() [1/2]

void game::examine ( )
private

Definition at line 5497 of file game.cpp.

5498{
5499 // if we are driving a vehicle, examine the
5500 // current tile without asking.
5501 const optional_vpart_position vp = m.veh_at( u.pos() );
5502 if( vp && vp->vehicle().player_in_control( u ) ) {
5503 examine( u.pos() );
5504 return;
5505 }
5506
5507 const cata::optional<tripoint> examp_ = choose_adjacent_highlight( _( "Examine where?" ),
5508 _( "There is nothing that can be examined nearby." ),
5509 ACTION_EXAMINE, false );
5510 if( !examp_ ) {
5511 return;
5512 }
5513 u.manual_examine = true;
5514 examine( *examp_ );
5515 u.manual_examine = false;
5516}
cata::optional< tripoint > choose_adjacent_highlight(const std::string &message, const std::string &failure_message, const action_id action, bool allow_vertical)
Request player input of adjacent tile with highlighting, possibly on different z-level.
Definition: action.cpp:1039
@ ACTION_EXAMINE
Examine or pick up items from adjacent square.
Definition: action.h:105
void examine()
Definition: game.cpp:5497
bool manual_examine
Definition: player.h:605

References _, ACTION_EXAMINE, choose_adjacent_highlight(), examine(), m, player::manual_examine, Character::pos(), u, and map::veh_at().

Referenced by examine(), and handle_action().

◆ examine() [2/2]

void game::examine ( const tripoint p)
private

Definition at line 5585 of file game.cpp.

5586{
5587 if( disable_robot( examp ) ) {
5588 return;
5589 }
5590
5591 Creature *c = critter_at( examp );
5592 if( c != nullptr ) {
5593 monster *mon = dynamic_cast<monster *>( c );
5594 if( mon != nullptr ) {
5595 add_msg( _( "There is a %s." ), mon->get_name() );
5596 if( mon->has_effect( effect_pet ) && !u.is_mounted() ) {
5597 if( monexamine::pet_menu( *mon ) ) {
5598 return;
5599 }
5600 } else if( mon->has_flag( MF_RIDEABLE_MECH ) && !mon->has_effect( effect_pet ) ) {
5601 if( monexamine::mech_hack( *mon ) ) {
5602 return;
5603 }
5604 } else if( mon->has_flag( MF_PAY_BOT ) ) {
5605 if( monexamine::pay_bot( *mon ) ) {
5606 return;
5607 }
5608 } else if( mon->attitude_to( u ) == Creature::A_FRIENDLY && !u.is_mounted() ) {
5609 if( monexamine::mfriend_menu( *mon ) ) {
5610 return;
5611 }
5612 }
5613 } else if( u.is_mounted() ) {
5614 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5615 }
5616 npc *np = dynamic_cast<npc *>( c );
5617 if( np != nullptr && !u.is_mounted() ) {
5618 if( npc_menu( *np ) ) {
5619 return;
5620 }
5621 } else if( np != nullptr && u.is_mounted() ) {
5622 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5623 }
5624 }
5625
5626 const optional_vpart_position vp = m.veh_at( examp );
5627 if( vp && u.is_mounted() ) {
5628 if( !u.mounted_creature->has_flag( MF_RIDEABLE_MECH ) ) {
5629 add_msg( m_warning, _( "You cannot interact with a vehicle while mounted." ) );
5630 } else {
5631 vp->vehicle().interact_with( examp, vp->part_index() );
5632 return;
5633 }
5634 } else if( vp && !u.is_mounted() ) {
5635 vp->vehicle().interact_with( examp, vp->part_index() );
5636 return;
5637 }
5638
5639 if( m.has_flag( "CONSOLE", examp ) && !u.is_mounted() ) {
5640 use_computer( examp );
5641 return;
5642 } else if( m.has_flag( "CONSOLE", examp ) && u.is_mounted() ) {
5643 add_msg( m_warning, _( "You cannot use a console while mounted." ) );
5644 }
5645 const furn_t &xfurn_t = m.furn( examp ).obj();
5646 const ter_t &xter_t = m.ter( examp ).obj();
5647
5648 const tripoint player_pos = u.pos();
5649
5650 if( m.has_furn( examp ) && !u.is_mounted() ) {
5651 xfurn_t.examine( u, examp );
5652 } else if( m.has_furn( examp ) && u.is_mounted() ) {
5653 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5654 } else {
5655 if( !u.is_mounted() ) {
5656 xter_t.examine( u, examp );
5657 } else if( u.is_mounted() && xter_t.examine == &iexamine::none ) {
5658 xter_t.examine( u, examp );
5659 } else {
5660 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5661 }
5662 }
5663
5664 // Did the player get moved? Bail out if so; our examp probably
5665 // isn't valid anymore.
5666 if( player_pos != u.pos() ) {
5667 return;
5668 }
5669
5670 bool none = true;
5671 if( xter_t.examine != &iexamine::none || xfurn_t.examine != &iexamine::none ) {
5672 none = false;
5673 }
5674
5675 if( !m.tr_at( examp ).is_null() && !u.is_mounted() ) {
5676 iexamine::trap( u, examp );
5677 } else if( !m.tr_at( examp ).is_null() && u.is_mounted() ) {
5678 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5679 }
5680
5681 // In case of teleport trap or somesuch
5682 if( player_pos != u.pos() ) {
5683 return;
5684 }
5685
5686 // Feedback for fire lasting time, this can be judged while mounted
5687 const std::string fire_fuel = get_fire_fuel_string( examp );
5688 if( !fire_fuel.empty() ) {
5689 add_msg( fire_fuel );
5690 }
5691
5692 if( m.has_flag( "SEALED", examp ) ) {
5693 if( none ) {
5694 if( m.has_flag( "UNSTABLE", examp ) ) {
5695 add_msg( _( "The %s is too unstable to remove anything." ), m.name( examp ) );
5696 } else {
5697 add_msg( _( "The %s is firmly sealed." ), m.name( examp ) );
5698 }
5699 }
5700 } else {
5701 //examp has no traps, is a container and doesn't have a special examination function
5702 if( m.tr_at( examp ).is_null() && m.i_at( examp ).empty() &&
5703 m.has_flag( "CONTAINER", examp ) && none ) {
5704 add_msg( _( "It is empty." ) );
5705 } else if( ( m.has_flag( TFLAG_FIRE_CONTAINER, examp ) &&
5706 xfurn_t.examine == &iexamine::fireplace ) ||
5707 xfurn_t.examine == &iexamine::workbench ) {
5708 return;
5709 } else {
5711 if( !u.is_mounted() ) {
5712 pickup::pick_up( examp, 0 );
5713 }
5714 }
5715 }
5716}
shared_ptr_fast< monster > mounted_creature
Definition: character.h:1556
@ A_FRIENDLY
Definition: creature.h:171
void use_computer(const tripoint &p)
Checks to see if a player can use a computer (not illiterate, etc.) and uses if able.
Definition: game.cpp:4636
bool disable_robot(const tripoint &p)
If there is a robot (that can be disabled), query the player and try to disable it.
Definition: game.cpp:8735
bool npc_menu(npc &who)
Returns true if the menu handled stuff and player shouldn't do anything else.
Definition: game.cpp:5388
bool empty() const
Definition: item_stack.cpp:15
bool has_furn(const tripoint &p) const
Definition: map.cpp:1343
const trap & tr_at(const tripoint &p) const
Definition: map.cpp:5125
ter_id ter(const tripoint &p) const
Definition: map.cpp:1498
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
Definition: monster.cpp:1040
std::string get_name() const override
Definition: monster.cpp:488
static std::string get_fire_fuel_string(const tripoint &examp)
Definition: game.cpp:5518
@ TFLAG_FIRE_CONTAINER
Definition: mapdata.h:293
void fireplace(player &p, const tripoint &examp)
Definition: iexamine.cpp:2893
void workbench(player &p, const tripoint &examp)
Definition: iexamine.cpp:6080
void none(player &p, const tripoint &examp)
Nothing player can interact with here.
Definition: iexamine.cpp:247
void trap(player &p, const tripoint &examp)
Definition: iexamine.cpp:3792
bool pet_menu(monster &z)
Definition: monexamine.cpp:67
bool mech_hack(monster &z)
Definition: monexamine.cpp:425
bool mfriend_menu(monster &z)
Definition: monexamine.cpp:497
bool pay_bot(monster &z)
Definition: monexamine.cpp:457
void pick_up(const tripoint &p, int min, from_where get_items_from=prompt)
Pick up items; 'g' or ',' or via examine()
Definition: pickup.cpp:571
iexamine_function examine
Definition: mapdata.h:398
Definition: mapdata.h:457
bool is_null() const
Whether this is the null-traps, aka no trap at all.
Definition: trap.cpp:245

References _, Creature::A_FRIENDLY, add_msg(), monster::attitude_to(), c, critter_at(), disable_robot(), effect_pet, item_stack::empty(), map_data_common_t::examine, iexamine::fireplace(), map::furn(), get_fire_fuel_string(), monster::get_name(), Creature::has_effect(), map::has_flag(), monster::has_flag(), map::has_furn(), map::i_at(), Character::is_mounted(), trap::is_null(), m, m_warning, monexamine::mech_hack(), MF_PAY_BOT, MF_RIDEABLE_MECH, monexamine::mfriend_menu(), Character::mounted_creature, map::name(), none, iexamine::none(), npc_menu(), int_id< T >::obj(), monexamine::pay_bot(), monexamine::pet_menu(), pickup::pick_up(), Character::pos(), sounds::process_sound_markers(), map::ter(), TFLAG_FIRE_CONTAINER, map::tr_at(), iexamine::trap(), u, use_computer(), map::veh_at(), and iexamine::workbench().

◆ extended_description()

void game::extended_description ( const tripoint p)

Long description of (visible) things at tile.

Definition at line 51 of file descriptions.cpp.

52{
54 const int top = 3;
55 int width = 0;
56 catacurses::window w_head;
57 catacurses::window w_main;
58 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
59 const int left = 0;
60 const int right = TERMX;
61 const int bottom = TERMY;
62 width = right - left;
63 const int height = bottom - top;
64 w_head = catacurses::newwin( top, TERMX, point_zero );
65 w_main = catacurses::newwin( height, width, point( left, top ) );
66 ui.position( point_zero, point( TERMX, TERMY ) );
67 } );
68 ui.mark_resize();
69
70 // Default to critter (if any), furniture (if any), then terrain.
72 if( seen_critter( *this, p ) != nullptr ) {
74 } else if( get_map().has_furn( p ) ) {
76 }
77
78 std::string action;
79 input_context ctxt( "EXTENDED_DESCRIPTION" );
80 ctxt.register_action( "CREATURE" );
81 ctxt.register_action( "FURNITURE" );
82 ctxt.register_action( "TERRAIN" );
83 ctxt.register_action( "CONFIRM" );
84 ctxt.register_action( "QUIT" );
85 ctxt.register_action( "HELP_KEYBINDINGS" );
86
87 ui.on_redraw( [&]( const ui_adaptor & ) {
88 werase( w_head );
90 _( "[%s] describe creatures, [%s] describe furniture, "
91 "[%s] describe terrain, [%s] close." ),
92 ctxt.get_desc( "CREATURE" ), ctxt.get_desc( "FURNITURE" ),
93 ctxt.get_desc( "TERRAIN" ), ctxt.get_desc( "QUIT" ) );
94
95 // Set up line drawings
96 for( int i = 0; i < TERMX; i++ ) {
97 mvwputch( w_head, point( i, top - 1 ), c_white, LINE_OXOX );
98 }
99
100 wnoutrefresh( w_head );
101
102 std::string desc;
103 // Allow looking at invisible tiles - player may want to examine hallucinations etc.
104 switch( cur_target ) {
106 const Creature *critter = seen_critter( *this, p );
107 if( critter != nullptr ) {
108 desc = critter->extended_description();
109 } else {
110 desc = _( "You do not see any creature here." );
111 }
112 }
113 break;
115 if( !u.sees( p ) || !m.has_furn( p ) ) {
116 desc = _( "You do not see any furniture here." );
117 } else {
118 const furn_id fid = m.furn( p );
119 if( display_mod_source ) {
120 const std::string mod_src = enumerate_as_string( fid->src.begin(),
121 fid->src.end(), []( const std::pair<furn_str_id, mod_id> &source ) {
122 return string_format( "'%s'", source.second->name() );
124 desc = string_format( _( "Origin: %s\n%s" ), mod_src, fid->extended_description() );
125 } else {
126 desc = fid.obj().extended_description();
127 }
128 }
129 break;
131 if( !u.sees( p ) ) {
132 desc = _( "You can't see the terrain here." );
133 } else {
134 const ter_id tid = m.ter( p );
135 if( display_mod_source ) {
136 const std::string mod_src = enumerate_as_string( tid->src.begin(),
137 tid->src.end(), []( const std::pair<ter_str_id, mod_id> &source ) {
138 return string_format( "'%s'", source.second->name() );
140 desc = string_format( _( "Origin: %s\n%s" ), mod_src, tid->extended_description() );
141 } else {
142 desc = tid.obj().extended_description();
143 }
144 }
145 break;
146 }
147
148 std::string signage = m.get_signage( p );
149 if( !signage.empty() ) {
150 // NOLINTNEXTLINE(cata-text-style): the question mark does not end a sentence
151 desc += u.has_trait( trait_ILLITERATE ) ? _( "\nSign: ???" ) : string_format( _( "\nSign: %s" ),
152 signage );
153 }
154
155 werase( w_main );
156 fold_and_print_from( w_main, point_zero, width, 0, c_light_gray, desc );
157 wnoutrefresh( w_main );
158 } );
159
160 do {
162 action = ctxt.handle_input();
163 if( action == "CREATURE" ) {
164 cur_target = description_target::creature;
165 } else if( action == "FURNITURE" ) {
167 } else if( action == "TERRAIN" ) {
168 cur_target = description_target::terrain;
169 }
170 } while( action != "CONFIRM" && action != "QUIT" );
171}
bool display_mod_source
Display mod source for items, furniture, terrain and monsters.
virtual std::string extended_description() const =0
friend map & get_map()
Definition: map.cpp:146
std::string get_signage(const tripoint &p) const
Definition: map.cpp:3989
static const trait_id trait_ILLITERATE("ILLITERATE")
static const Creature * seen_critter(const game &g, const tripoint &p)
description_target
int fold_and_print_from(const catacurses::window &w, const point &begin, int width, int begin_line, const nc_color &base_color, const std::string &text)
Like fold_and_print, but starts the output with the N-th line of the folded string.
Definition: output.cpp:311
std::vector< std::pair< furn_str_id, mod_id > > src
Definition: mapdata.h:494
std::string extended_description() const
std::vector< std::pair< ter_str_id, mod_id > > src
Definition: mapdata.h:459

References _, action, arrow, c_light_gray, c_white, creature, display_mod_source, enumerate_as_string(), map_data_common_t::extended_description(), Creature::extended_description(), fold_and_print_from(), map::furn(), furniture, input_context::get_desc(), get_map, map::get_signage(), input_context::handle_input(), map::has_furn(), Character::has_trait(), left, LINE_OXOX, m, mvwprintz(), mvwputch(), catacurses::newwin(), int_id< T >::obj(), point_zero, ui_manager::redraw(), input_context::register_action(), right, seen_critter(), Character::sees(), ter_t::src, furn_t::src, string_format(), map::ter(), TERMX, TERMY, terrain, trait_ILLITERATE, u, catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by look_around().

◆ find_nearby_items()

std::vector< map_item_stack > game::find_nearby_items ( int  iRadius)
private

Definition at line 7035 of file game.cpp.

7036{
7037 std::map<std::string, map_item_stack> temp_items;
7038 std::vector<map_item_stack> ret;
7039 std::vector<std::string> item_order;
7040
7041 if( u.is_blind() ) {
7042 return ret;
7043 }
7044
7045 int range = fov_3d ? ( fov_3d_z_range * 2 ) + 1 : 1;
7046 int center_z = u.pos().z;
7047
7048 for( int i = 1; i <= range; i++ ) {
7049 int z = i % 2 ? center_z - i / 2 : center_z + i / 2;
7050 for( auto &points_p_it : closest_points_first( {u.pos().xy(), z}, iRadius ) ) {
7051 if( points_p_it.y >= u.posy() - iRadius && points_p_it.y <= u.posy() + iRadius &&
7052 u.sees( points_p_it ) &&
7053 m.sees_some_items( points_p_it, u ) ) {
7054
7055 for( auto &elem : m.i_at( points_p_it ) ) {
7056 const std::string name = elem.tname();
7057 const tripoint relative_pos = points_p_it - u.pos();
7058
7059 if( std::find( item_order.begin(), item_order.end(), name ) == item_order.end() ) {
7060 item_order.push_back( name );
7061 temp_items[name] = map_item_stack( &elem, relative_pos );
7062 } else {
7063 temp_items[name].add_at_pos( &elem, relative_pos );
7064 }
7065 }
7066 }
7067 }
7068 }
7069
7070 for( auto &elem : item_order ) {
7071 ret.push_back( temp_items[elem] );
7072 }
7073
7074 return ret;
7075}
int fov_3d_z_range
3D FoV range, in Z levels, in both directions.
bool fov_3d
3D FoV enabled/disabled.
bool is_blind() const
Returns true if the player isn't able to see.
Definition: character.cpp:6342
std::vector< coords::coord_point< Point, Origin, Scale > > closest_points_first(const coords::coord_point< Point, Origin, Scale > &loc, int min_dist, int max_dist)
Definition: coordinates.h:596

References closest_points_first(), detail::find(), fov_3d, fov_3d_z_range, map::i_at(), Character::is_blind(), m, om_direction::name(), Character::pos(), Character::posy(), cata::hash64_detail::ret, Character::sees(), map::sees_some_items(), u, and tripoint::z.

Referenced by list_items_monsters().

◆ find_npc()

npc * game::find_npc ( character_id  id)

Find the npc with the given ID.

Returns NULL if the npc could not be found. Searches all loaded overmaps.

Definition at line 1978 of file game.cpp.

1979{
1980 return overmap_buffer.find_npc( id ).get();
1981}

References overmapbuffer::find_npc(), and overmap_buffer.

Referenced by critter_by_id().

◆ find_or_make_stairs()

cata::optional< tripoint > game::find_or_make_stairs ( map mp,
int  z_after,
bool &  rope_ladder,
bool  peeking 
)

Returns the other end of the stairs (if any).

May query, affect u etc.

Definition at line 10524 of file game.cpp.

10526{
10527 const int omtilesz = SEEX * 2;
10528 real_coords rc( m.getabs( point( u.posx(), u.posy() ) ) );
10529 tripoint omtile_align_start( m.getlocal( rc.begin_om_pos() ), z_after );
10530 tripoint omtile_align_end( omtile_align_start + point( -1 + omtilesz, -1 + omtilesz ) );
10531
10532 // Try to find the stairs.
10534 int best = INT_MAX;
10535 const int movez = z_after - get_levz();
10536 const bool going_down_1 = movez == -1;
10537 const bool going_up_1 = movez == 1;
10538 // If there are stairs on the same x and y as we currently are, use those
10539 if( going_down_1 && mp.has_flag( TFLAG_GOES_UP, u.pos() + tripoint_below ) ) {
10540 stairs.emplace( u.pos() + tripoint_below );
10541 }
10542 if( going_up_1 && mp.has_flag( TFLAG_GOES_DOWN, u.pos() + tripoint_above ) ) {
10543 stairs.emplace( u.pos() + tripoint_above );
10544 }
10545 // We did not find stairs directly above or below, so search the map for them
10546 if( !stairs.has_value() ) {
10547 for( const tripoint &dest : m.points_in_rectangle( omtile_align_start, omtile_align_end ) ) {
10548 if( rl_dist( u.pos(), dest ) <= best &&
10549 ( ( going_down_1 && mp.has_flag( TFLAG_GOES_UP, dest ) ) ||
10550 ( going_up_1 && ( mp.has_flag( TFLAG_GOES_DOWN, dest ) ||
10551 mp.ter( dest ) == t_manhole_cover ) ) ||
10552 ( ( movez == 2 || movez == -2 ) && mp.ter( dest ) == t_elevator ) ) ) {
10553 stairs.emplace( dest );
10554 best = rl_dist( u.pos(), dest );
10555 }
10556 }
10557 }
10558
10559 if( stairs.has_value() ) {
10560 if( Creature *blocking_creature = critter_at( stairs.value() ) ) {
10561 npc *guy = dynamic_cast<npc *>( blocking_creature );
10562 monster *mon = dynamic_cast<monster *>( blocking_creature );
10563 bool would_move = ( guy && !guy->is_enemy() ) || ( mon && mon->friendly == -1 );
10564 bool can_displace = find_empty_spot_nearby( *stairs ).has_value();
10565 std::string cr_name = blocking_creature->get_name();
10566 std::string msg;
10567 if( guy ) {
10568 //~ %s is the name of hostile NPC
10569 msg = string_format( _( "%s is in the way!" ), cr_name );
10570 } else {
10571 //~ %s is some monster
10572 msg = string_format( _( "There's a %s in the way!" ), cr_name );
10573 }
10574
10575 if( ( peeking && !would_move ) || !can_displace || ( !would_move && !query_yn(
10576 //~ %s is a warning about monster/hostile NPC in the way, e.g. "There's a zombie in the way!"
10577 _( "%s Attempt to push past? You may have to fight your way back up." ), msg ) ) ) {
10578 add_msg( msg );
10579 return cata::nullopt;
10580 }
10581 }
10582 return stairs;
10583 }
10584
10585 // No stairs found! Try to make some
10586 rope_ladder = false;
10587 stairs.emplace( u.pos() );
10588 stairs->z = z_after;
10589 // Check the destination area for lava.
10590 if( mp.ter( *stairs ) == t_lava ) {
10591 if( movez < 0 &&
10592 !query_yn(
10593 _( "There is a LOT of heat coming out of there, even the stairs have melted away. Jump down? You won't be able to get back up." ) ) ) {
10594 return cata::nullopt;
10595 } else if( movez > 0 &&
10596 !query_yn(
10597 _( "There is a LOT of heat coming out of there. Push through the half-molten rocks and ascend? You will not be able to get back down." ) ) ) {
10598 return cata::nullopt;
10599 }
10600
10601 return stairs;
10602 }
10603
10604 if( movez > 0 ) {
10605 if( !mp.has_flag( "GOES_DOWN", *stairs ) ) {
10606 if( !query_yn( _( "You may be unable to return back down these stairs. Continue up?" ) ) ) {
10607 return cata::nullopt;
10608 }
10609 }
10610 // Manhole covers need this to work
10611 // Maybe require manhole cover here and fail otherwise?
10612 return stairs;
10613 }
10614
10615 if( mp.impassable( *stairs ) ) {
10616 popup( _( "Halfway down, the way down becomes blocked off." ) );
10617 return cata::nullopt;
10618 }
10619
10620 if( u.has_trait( trait_id( "WEB_RAPPEL" ) ) ) {
10621 if( query_yn( _( "There is a sheer drop halfway down. Web-descend?" ) ) ) {
10622 rope_ladder = true;
10623 if( ( rng( 4, 8 ) ) < u.get_skill_level( skill_dodge ) ) {
10624 add_msg( _( "You attach a web and dive down headfirst, flipping upright and landing on your feet." ) );
10625 } else {
10626 add_msg( _( "You securely web up and work your way down, lowering yourself safely." ) );
10627 }
10628 } else {
10629 return cata::nullopt;
10630 }
10631 } else if( u.has_trait( trait_VINES2 ) || u.has_trait( trait_VINES3 ) ) {
10632 if( query_yn( _( "There is a sheer drop halfway down. Use your vines to descend?" ) ) ) {
10633 if( u.has_trait( trait_VINES2 ) ) {
10634 if( query_yn( _( "Detach a vine? It'll hurt, but you'll be able to climb back up…" ) ) ) {
10635 rope_ladder = true;
10636 add_msg( m_bad, _( "You descend on your vines, though leaving a part of you behind stings." ) );
10637 u.mod_pain( 5 );
10638 u.apply_damage( nullptr, bodypart_id( "torso" ), 5 );
10639 u.mod_stored_nutr( 10 );
10640 u.mod_thirst( 10 );
10641 } else {
10642 add_msg( _( "You gingerly descend using your vines." ) );
10643 }
10644 } else {
10645 add_msg( _( "You effortlessly lower yourself and leave a vine rooted for future use." ) );
10646 rope_ladder = true;
10647 u.mod_stored_nutr( 10 );
10648 u.mod_thirst( 10 );
10649 }
10650 } else {
10651 return cata::nullopt;
10652 }
10653 } else if( u.has_amount( itype_grapnel, 1 ) ) {
10654 if( query_yn( _( "There is a sheer drop halfway down. Climb your grappling hook down?" ) ) ) {
10655 rope_ladder = true;
10657 } else {
10658 return cata::nullopt;
10659 }
10660 } else if( u.has_amount( itype_rope_30, 1 ) ) {
10661 if( query_yn( _( "There is a sheer drop halfway down. Climb your rope down?" ) ) ) {
10662 rope_ladder = true;
10664 } else {
10665 return cata::nullopt;
10666 }
10667 } else if( !query_yn( _( "There is a sheer drop halfway down. Jump?" ) ) ) {
10668 return cata::nullopt;
10669 }
10670
10671 return stairs;
10672}
int_id< body_part_type > bodypart_id
Definition: bodypart.h:23
void apply_damage(Creature *source, bodypart_id hurt, int dam, bool bypass_med=false) override
Actually hurt the player, hurts a body_part directly, no armor reduction.
Definition: character.cpp:8407
std::list< item > use_amount(itype_id it, int quantity, const std::function< bool(const item &)> &filter=return_true< item >)
Definition: character.cpp:9631
virtual void mod_thirst(int nthirst)
Definition: character.cpp:4414
virtual void mod_stored_nutr(int nnutr)
Definition: character.cpp:4304
int get_skill_level(const skill_id &ident) const
Definition: character.cpp:3356
T & emplace(Args &&... args)
Definition: optional.h:146
constexpr bool has_value() const noexcept
Definition: optional.h:123
tripoint getlocal(const tripoint &p) const
Inverse of getabs.
Definition: map.cpp:8266
bool impassable(const tripoint &p) const
Definition: map.cpp:1795
tripoint_range< tripoint > points_in_rectangle(const tripoint &from, const tripoint &to) const
Definition: map.cpp:8595
bool is_enemy() const
Definition: npc.cpp:2043
void mod_pain(int npain) override
Modifies a pain value by player traits before passing it to Creature::mod_pain()
Definition: player.cpp:945
static const trait_id trait_VINES2("VINES2")
static const skill_id skill_dodge("dodge")
static cata::optional< tripoint > find_empty_spot_nearby(const tripoint &pos)
Definition: game.cpp:10060
static const itype_id itype_rope_30("rope_30")
static const itype_id itype_grapnel("grapnel")
static const trait_id trait_VINES3("VINES3")
ter_id t_manhole_cover
Definition: mapdata.cpp:720
ter_id t_lava
Definition: mapdata.cpp:695
ter_id t_elevator
Definition: mapdata.cpp:723
@ TFLAG_GOES_DOWN
Definition: mapdata.h:308
@ TFLAG_GOES_UP
Definition: mapdata.h:309
static constexpr nullopt_t nullopt
Definition: optional.h:22
static constexpr tripoint tripoint_below
Definition: point.h:295
static constexpr tripoint tripoint_above
Definition: point.h:294

References _, add_msg(), Character::apply_damage(), real_coords::begin_om_pos(), critter_at(), cata::optional< T >::emplace(), find_empty_spot_nearby(), monster::friendly, get_levz(), Character::get_skill_level(), map::getabs(), map::getlocal(), visitable< T >::has_amount(), map::has_flag(), Character::has_trait(), cata::optional< T >::has_value(), map::impassable(), npc::is_enemy(), itype_grapnel, itype_rope_30, m, m_bad, player::mod_pain(), Character::mod_stored_nutr(), Character::mod_thirst(), cata::nullopt, map::points_in_rectangle(), popup(), Character::pos(), Character::posx(), Character::posy(), query_yn(), rl_dist(), rng(), SEEX, skill_dodge, string_format(), t_elevator, t_lava, t_manhole_cover, map::ter(), TFLAG_GOES_DOWN, TFLAG_GOES_UP, trait_VINES2, trait_VINES3, tripoint_above, tripoint_below, u, Character::use_amount(), and cata::optional< T >::value().

Referenced by vertical_move().

◆ fling_creature()

void game::fling_creature ( Creature c,
const units::angle dir,
float  flvel,
bool  controlled = false,
bool  suppress_map_update = false 
)

Flings the input creature in the given direction.

Definition at line 9862 of file game.cpp.

9864{
9865 if( c == nullptr ) {
9866 debugmsg( "game::fling_creature invoked on null target" );
9867 return;
9868 }
9869
9870 if( c->is_dead_state() ) {
9871 // Flinging a corpse causes problems, don't enable without testing
9872 return;
9873 }
9874
9875 if( c->is_hallucination() ) {
9876 // Don't fling hallucinations
9877 return;
9878 }
9879
9880 bool thru = true;
9881 const bool is_u = ( c == &u );
9882 // Don't animate critters getting bashed if animations are off
9883 const bool animate = is_u || get_option<bool>( "ANIMATIONS" );
9884
9885 player *p = dynamic_cast<player *>( c );
9886
9887 tileray tdir( dir );
9888 int range = flvel / 10;
9889 tripoint pt = c->pos();
9890 tripoint prev_point = pt;
9891 bool force_next = false;
9892 tripoint next_forced;
9893 while( range > 0 ) {
9894 c->underwater = false;
9895 // TODO: Check whenever it is actually in the viewport
9896 // or maybe even just redraw the changed tiles
9897 bool seen = is_u || u.sees( *c ); // To avoid redrawing when not seen
9898 if( force_next ) {
9899 pt = next_forced;
9900 force_next = false;
9901 } else {
9902 tdir.advance();
9903 pt.x = c->posx() + tdir.dx();
9904 pt.y = c->posy() + tdir.dy();
9905 }
9906 float force = 0;
9907
9908 if( m.obstructed_by_vehicle_rotation( prev_point, pt ) ) {
9909 //We process the intervening tile on this iteration and then the current tile on the next
9910 next_forced = pt;
9911 force_next = true;
9912 if( one_in( 2 ) ) {
9913 pt.x = prev_point.x;
9914 } else {
9915 pt.y = prev_point.y;
9916 }
9917 }
9918
9919
9920 if( monster *const mon_ptr = critter_at<monster>( pt ) ) {
9921 monster &critter = *mon_ptr;
9922 // Approximate critter's "stopping power" with its max hp
9923 force = std::min<float>( 1.5f * critter.type->hp, flvel );
9924 const int damage = rng( force, force * 2.0f ) / 6;
9925 c->impact( damage, pt );
9926 // Multiply zed damage by 6 because no body parts
9927 const int zed_damage = std::max( 0,
9928 ( damage - critter.get_armor_bash( bodypart_id( "torso" ) ) ) * 6 );
9929 // TODO: Pass the "flinger" here - it's not the flung critter that deals damage
9930 critter.apply_damage( c, bodypart_id( "torso" ), zed_damage );
9931 critter.check_dead_state();
9932 if( !critter.is_dead() ) {
9933 thru = false;
9934 }
9935 } else if( m.impassable( pt ) ) {
9936 if( !m.veh_at( pt ).obstacle_at_part() ) {
9937 force = std::min<float>( m.bash_strength( pt ), flvel );
9938 } else {
9939 // No good way of limiting force here
9940 // Keep it 1 less than maximum to make the impact hurt
9941 // but to keep the target flying after it
9942 force = flvel - 1;
9943 }
9944 const int damage = rng( force, force * 2.0f ) / 9;
9945 c->impact( damage, pt );
9946 if( m.is_bashable( pt ) ) {
9947 // Only go through if we successfully make the tile passable
9948 m.bash( pt, flvel );
9949 thru = m.passable( pt );
9950 } else {
9951 thru = false;
9952 }
9953 }
9954
9955 // If the critter dies during flinging, moving it around causes debugmsgs
9956 if( c->is_dead_state() ) {
9957 return;
9958 }
9959
9960 flvel -= force;
9961 if( thru ) {
9962 if( p != nullptr ) {
9963 if( p->in_vehicle ) {
9964 m.unboard_vehicle( p->pos() );
9965 }
9966 // If we're flinging the player around, make sure the map stays centered on them.
9967 if( is_u && !suppress_map_update ) {
9968 update_map( pt.x, pt.y );
9969 } else {
9970 p->setpos( pt );
9971 }
9972 } else if( !critter_at( pt ) ) {
9973 // Dying monster doesn't always leave an empty tile (blob spawning etc.)
9974 // Just don't setpos if it happens - next iteration will do so
9975 // or the monster will stop a tile before the unpassable one
9976 c->setpos( pt );
9977 }
9978 } else {
9979 // Don't zero flvel - count this as slamming both the obstacle and the ground
9980 // although at lower velocity
9981 break;
9982 }
9983 //Vehicle wall tiles don't count for range
9984 if( !force_next ) {
9985 range--;
9986 }
9987 prev_point = pt;
9988 if( animate && ( seen || u.sees( *c ) ) ) {
9993 }
9994 }
9995
9996 // Fall down to the ground - always on the last reached tile
9997 if( !m.has_flag( "SWIMMABLE", c->pos() ) ) {
9998 const trap_id trap_under_creature = m.tr_at( c->pos() ).loadid;
9999 // Didn't smash into a wall or a floor so only take the fall damage
10000 if( thru && trap_under_creature == tr_ledge ) {
10001 m.creature_on_trap( *c, false );
10002 } else {
10003 // Fall on ground
10004 int force = rng( flvel, flvel * 2 ) / 9;
10005 if( controlled ) {
10006 force = std::max( force / 2 - 5, 0 );
10007 }
10008 if( force > 0 ) {
10009 int dmg = c->impact( force, c->pos() );
10010 // TODO: Make landing damage the floor
10011 m.bash( c->pos(), dmg / 4, false, false, false );
10012 }
10013 // Always apply traps to creature i.e. bear traps, tele traps etc.
10014 m.creature_on_trap( *c, false );
10015 }
10016 } else {
10017 c->underwater = true;
10018 if( is_u ) {
10019 if( controlled ) {
10020 add_msg( _( "You dive into water." ) );
10021 } else {
10022 add_msg( m_warning, _( "You fall into water." ) );
10023 }
10024 }
10025 }
10026}
void setpos(const tripoint &p) override
Definition: character.h:797
void check_dead_state()
This function checks the creatures is_dead_state and (if true) calls die.
Definition: creature.cpp:1839
point update_map(player &p)
Definition: game.cpp:10751
void pump_events()
Resize & refresh if necessary, process all pending window events, and ignore keypresses.
int bash_strength(const tripoint &p, bool allow_floor=false) const
Returns max_str of the furniture or terrain at p.
Definition: map.cpp:2449
bool obstructed_by_vehicle_rotation(const tripoint &from, const tripoint &to) const
Checks if a rotated vehicle is blocking diagonal movement, tripoints must be adjacent.
Definition: map.cpp:6482
bash_results bash(const tripoint &p, int str, bool silent=false, bool destroy=false, bool bash_floor=false, const vehicle *bashing_vehicle=nullptr)
Returns a pair where first is whether anything was smashed and second is if it was destroyed.
Definition: map.cpp:3516
void unboard_vehicle(const vpart_reference &, Character *passenger, bool dead_passenger=false)
Definition: map.cpp:1081
bool is_bashable(const tripoint &p, bool allow_floor=false) const
Returns true if there is a bashable vehicle part or the furn/terrain is bashable at p.
Definition: map.cpp:2414
void creature_on_trap(Creature &critter, bool may_avoid=true)
Apply trap effects to the creature, similar to creature_in_field.
Definition: map.cpp:8472
bool passable(const tripoint &p) const
Definition: map.cpp:1800
int get_armor_bash(bodypart_id bp) const override
Definition: monster.cpp:1880
bool is_dead() const
Definition: monster.cpp:2778
void apply_damage(Creature *source, bodypart_id bp, int dam, bool bypass_med=false) override
Definition: monster.cpp:1661
cata::optional< vpart_reference > obstacle_at_part() const
Definition: vehicle.cpp:2493
static const trap_str_id tr_ledge("tr_ledge")
void redraw_invalidated()
Redraw all invalidated windows without invalidating the top window.
Definition: ui_manager.cpp:394
int hp
Definition: mtype.h:270
trap_id loadid
Definition: trap.h:88
int y
Definition: point.h:151
int x
Definition: point.h:150

References _, add_msg(), tileray::advance(), monster::apply_damage(), map::bash(), map::bash_strength(), c, Creature::check_dead_state(), map::creature_on_trap(), critter_at(), debugmsg, tileray::dx(), tileray::dy(), monster::get_armor_bash(), map::has_flag(), mtype::hp, map::impassable(), Character::in_vehicle, inp_mngr, invalidate_main_ui_adaptor(), map::is_bashable(), monster::is_dead(), trap::loadid, m, m_warning, optional_vpart_position::obstacle_at_part(), map::obstructed_by_vehicle_rotation(), one_in(), map::passable(), Character::pos(), input_manager::pump_events(), ui_manager::redraw_invalidated(), refresh_display(), rng(), Character::sees(), Character::setpos(), map::tr_at(), tr_ledge, monster::type, u, map::unboard_vehicle(), update_map(), map::veh_at(), tripoint::x, and tripoint::y.

Referenced by moving_vehicle_dismount().

◆ forced_door_closing()

bool game::forced_door_closing ( const tripoint p,
const ter_id door_type,
int  bash_dmg 
)

Definition at line 5119 of file game.cpp.

5120{
5121 const auto valid_location = [&]( const tripoint & p ) {
5122 return g->is_empty( p );
5123 };
5124 const auto get_random_point = [&]() -> tripoint {
5125 if( auto pos = random_point( m.points_in_radius( p, 2 ), valid_location ) )
5126 {
5127 return p * 2 - ( *pos );
5128 } else
5129 {
5130 return p;
5131 }
5132 };
5133
5134 const std::string &door_name = door_type.obj().name();
5135 const tripoint kbp = get_random_point();
5136
5137 // can't pushback any creatures/items anywhere, that means the door can't close.
5138 const bool cannot_push = kbp == p;
5139 const bool can_see = u.sees( p );
5140
5141 player *npc_or_player = critter_at<player>( p, false );
5142 if( npc_or_player != nullptr ) {
5143 if( bash_dmg <= 0 ) {
5144 return false;
5145 }
5146 if( npc_or_player->is_npc() && can_see ) {
5147 add_msg( _( "The %1$s hits the %2$s." ), door_name, npc_or_player->name );
5148 } else if( npc_or_player->is_player() ) {
5149 add_msg( m_bad, _( "The %s hits you." ), door_name );
5150 }
5151 if( npc_or_player->activity ) {
5152 npc_or_player->cancel_activity();
5153 }
5154 // TODO: make the npc angry?
5155 npc_or_player->hitall( bash_dmg, 0, nullptr );
5156 if( cannot_push ) {
5157 return false;
5158 }
5159 // TODO implement who was closing the door and replace nullptr
5160 knockback( kbp, p, std::max( 1, bash_dmg / 10 ), -1, 1, nullptr );
5161 // TODO: perhaps damage/destroy the gate
5162 // if the npc was really big?
5163 }
5164 if( monster *const mon_ptr = critter_at<monster>( p ) ) {
5165 monster &critter = *mon_ptr;
5166 if( bash_dmg <= 0 ) {
5167 return false;
5168 }
5169 if( can_see ) {
5170 add_msg( _( "The %1$s hits the %2$s." ), door_name, critter.name() );
5171 }
5172 if( critter.type->size <= MS_SMALL ) {
5173 critter.die_in_explosion( nullptr );
5174 } else {
5175 critter.apply_damage( nullptr, bodypart_id( "torso" ), bash_dmg );
5176 critter.check_dead_state();
5177 }
5178 if( !critter.is_dead() && critter.type->size >= MS_HUGE ) {
5179 // big critters simply prevent the gate from closing
5180 // TODO: perhaps damage/destroy the gate
5181 // if the critter was really big?
5182 return false;
5183 }
5184 if( !critter.is_dead() ) {
5185 // Still alive? Move the critter away so the door can close
5186 if( cannot_push ) {
5187 return false;
5188 }
5189 // TODO implement who was closing the door and replace nullptr
5190 knockback( kbp, p, std::max( 1, bash_dmg / 10 ), -1, 1, nullptr );
5191 if( critter_at( p ) ) {
5192 return false;
5193 }
5194 }
5195 }
5196 if( const optional_vpart_position vp = m.veh_at( p ) ) {
5197 if( bash_dmg <= 0 ) {
5198 return false;
5199 }
5200 vp->vehicle().damage( vp->part_index(), bash_dmg );
5201 if( m.veh_at( p ) ) {
5202 // Check again in case all parts at the door tile
5203 // have been destroyed, if there is still a vehicle
5204 // there, the door can not be closed
5205 return false;
5206 }
5207 }
5208 if( bash_dmg < 0 && !m.i_at( p ).empty() ) {
5209 return false;
5210 }
5211 if( bash_dmg == 0 ) {
5212 for( auto &elem : m.i_at( p ) ) {
5213 if( elem.made_of( LIQUID ) ) {
5214 // Liquids are OK, will be destroyed later
5215 continue;
5216 } else if( elem.volume() < 250_ml ) {
5217 // Dito for small items, will be moved away
5218 continue;
5219 }
5220 // Everything else prevents the door from closing
5221 return false;
5222 }
5223 }
5224
5225 m.ter_set( p, door_type );
5226 if( m.has_flag( "NOITEM", p ) ) {
5227 map_stack items = m.i_at( p );
5228 for( map_stack::iterator it = items.begin(); it != items.end(); ) {
5229 if( it->made_of( LIQUID ) ) {
5230 it = items.erase( it );
5231 continue;
5232 }
5233 if( it->made_of( material_id( "glass" ) ) && one_in( 2 ) ) {
5234 if( can_see ) {
5235 add_msg( m_warning, _( "A %s shatters!" ), it->tname() );
5236 } else {
5237 add_msg( m_warning, _( "Something shatters!" ) );
5238 }
5239 it = items.erase( it );
5240 continue;
5241 }
5242 if( cannot_push ) {
5243 return false;
5244 }
5245 m.add_item_or_charges( kbp, *it );
5246 it = items.erase( it );
5247 }
5248 }
5249 return true;
5250}
int hitall(int dam, int vary, Creature *source)
Harms all body parts for dam, with armor reduction.
Definition: character.cpp:8684
void knockback(const tripoint &s, const tripoint &t, int force, int stun, int dam_mult, Creature *source)
Definition: game.cpp:4396
iterator erase(const_iterator it) override
Definition: map.cpp:152
bool ter_set(const tripoint &p, const ter_id &new_terrain)
Definition: map.cpp:1639
void die_in_explosion(Creature *source)
Definition: monster.cpp:1675
bool is_npc() const override
Definition: player.h:123
bool is_player() const override
Definition: player.h:106
@ MS_SMALL
Definition: creature.h:59
@ MS_HUGE
Definition: creature.h:62
@ LIQUID
Definition: enums.h:175
cata::optional< tripoint > random_point(const map &m, const std::function< bool(const tripoint &)> &predicate)
Same as other random_point with a range enclosing all valid points of the map.
std::string name() const
Definition: mapdata.cpp:511
m_size size
Definition: mtype.h:262

References _, Character::activity, map::add_item_or_charges(), add_msg(), monster::apply_damage(), item_stack::begin(), Character::cancel_activity(), Creature::check_dead_state(), critter_at(), monster::die_in_explosion(), item_stack::empty(), item_stack::end(), map_stack::erase(), g, map::has_flag(), Character::hitall(), map::i_at(), monster::is_dead(), player::is_npc(), player::is_player(), knockback(), LIQUID, m, m_bad, m_warning, MS_HUGE, MS_SMALL, Character::name, map_data_common_t::name(), monster::name(), int_id< T >::obj(), one_in(), map::points_in_radius(), random_point(), Character::sees(), mtype::size, map::ter_set(), monster::type, u, and map::veh_at().

◆ gametype()

special_game_id game::gametype ( ) const

Definition at line 643 of file game.cpp.

644{
645 return gamemode ? gamemode->id() : SGAME_NULL;
646}
@ SGAME_NULL
Definition: enums.h:93

References gamemode, and SGAME_NULL.

◆ get_creature_if()

Creature * game::get_creature_if ( const std::function< bool(const Creature &)> &  pred)

Returns a creature matching a predicate.

Only living (not dead) creatures are checked. Returns nullptr if no creature matches the predicate. There is no guarantee which creature is returned when several creatures match.

Definition at line 12098 of file game.cpp.

12099{
12100 for( Creature &critter : all_creatures() ) {
12101 if( pred( critter ) ) {
12102 return &critter;
12103 }
12104 }
12105 return nullptr;
12106}

References all_creatures().

◆ get_creatures_if()

std::vector< Creature * > game::get_creatures_if ( const std::function< bool(const Creature &)> &  pred)

Returns all creatures matching a predicate.

Only living ( not dead ) creatures are checked ( and returned ). Returned pointers are never null.

Definition at line 12008 of file game.cpp.

12010{
12011 std::vector<Creature *> result;
12012 for( Creature &critter : all_creatures() ) {
12013 if( pred( critter ) ) {
12014 result.push_back( &critter );
12015 }
12016 }
12017 return result;
12018}

References all_creatures().

◆ get_cur_om()

overmap & game::get_cur_om ( ) const

The overmap which contains the center submap of the reality bubble.

Definition at line 11988 of file game.cpp.

11989{
11990 // The player is located in the middle submap of the map.
11992 const tripoint pos_om = sm_to_om_copy( sm );
11993 // TODO: fix point types
11994 return overmap_buffer.get( point_abs_om( pos_om.xy() ) );
11995}
tripoint get_abs_sub() const
return abs_sub
Definition: map.cpp:8276
overmap & get(const point_abs_om &)
Uses overmap coordinates, that means x and y are directly compared with the position of the overmap.
point sm_to_om_copy(const point &p)
coords::coord_point< point, coords::origin::abs, coords::om > point_abs_om
Definition: coordinates.h:483
static constexpr int HALF_MAPSIZE
constexpr scale sm
Definition: coordinates.h:31

References overmapbuffer::get(), map::get_abs_sub(), HALF_MAPSIZE, m, overmap_buffer, coords::sm, sm_to_om_copy(), and tripoint::xy().

Referenced by start_game().

◆ get_dangerous_tile()

std::vector< std::string > game::get_dangerous_tile ( const tripoint dest_loc) const

Definition at line 8819 of file game.cpp.

8820{
8821 std::vector<std::string> harmful_stuff;
8822 const auto fields_here = m.field_at( u.pos() );
8823 for( const auto &e : m.field_at( dest_loc ) ) {
8824 // warn before moving into a dangerous field except when already standing within a similar field
8825 if( u.is_dangerous_field( e.second ) && fields_here.find_field( e.first ) == nullptr ) {
8826 harmful_stuff.push_back( e.second.name() );
8827 }
8828 }
8829
8830 if( !u.is_blind() ) {
8831 const trap &tr = m.tr_at( dest_loc );
8832 const bool boardable = static_cast<bool>( m.veh_at( dest_loc ).part_with_feature( "BOARDABLE",
8833 true ) );
8834 // HACK: Hack for now, later ledge should stop being a trap
8835 // Note: in non-z-level mode, ledges obey different rules and so should be handled as regular traps
8836 if( tr.loadid == tr_ledge && m.has_zlevels() ) {
8837 if( !boardable ) {
8838 harmful_stuff.emplace_back( tr.name() );
8839 }
8840 } else if( tr.can_see( dest_loc, u ) && !tr.is_benign() && !boardable ) {
8841 harmful_stuff.emplace_back( tr.name() );
8842 }
8843
8844 static const std::set< body_part > sharp_bps = {
8847 };
8848
8849 const auto sharp_bp_check = [this]( body_part bp ) {
8850 return u.immune_to( bp, { DT_CUT, 10 } );
8851 };
8852
8853 if( m.has_flag( "ROUGH", dest_loc ) && !m.has_flag( "ROUGH", u.pos() ) && !boardable &&
8854 ( u.get_armor_bash( bodypart_id( "foot_l" ) ) < 5 ||
8855 u.get_armor_bash( bodypart_id( "foot_r" ) ) < 5 ) ) {
8856 harmful_stuff.emplace_back( m.name( dest_loc ) );
8857 } else if( m.has_flag( "SHARP", dest_loc ) && !m.has_flag( "SHARP", u.pos() ) && !( u.in_vehicle ||
8858 m.veh_at( dest_loc ) ) &&
8859 u.dex_cur < 78 && !std::all_of( sharp_bps.begin(), sharp_bps.end(), sharp_bp_check ) ) {
8860 harmful_stuff.emplace_back( m.name( dest_loc ) );
8861 }
8862
8863 }
8864
8865 return harmful_stuff;
8866}
@ bp_foot_l
Definition: bodypart.h:50
@ bp_leg_r
Definition: bodypart.h:49
@ bp_eyes
Definition: bodypart.h:42
@ bp_hand_l
Definition: bodypart.h:46
@ bp_arm_l
Definition: bodypart.h:44
@ bp_leg_l
Definition: bodypart.h:48
@ bp_hand_r
Definition: bodypart.h:47
@ bp_head
Definition: bodypart.h:41
@ bp_torso
Definition: bodypart.h:40
@ bp_mouth
Definition: bodypart.h:43
@ bp_foot_r
Definition: bodypart.h:51
@ bp_arm_r
Definition: bodypart.h:45
int dex_cur
Definition: character.h:248
int get_armor_bash(bodypart_id bp) const override
Returns overall bashing resistance for the body_part.
Definition: character.cpp:6971
bool is_dangerous_field(const field_entry &entry) const
Returns true if the given field entry is dangerous to us.
Definition: creature.cpp:196
const field & field_at(const tripoint &p) const
Get the fields that are here.
Definition: map.cpp:5287
bool has_zlevels() const
Definition: map.h:1685
cata::optional< vpart_reference > part_with_feature(const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2481
bool immune_to(body_part bp, damage_unit dam) const
Check if a given body part is immune to a given damage type.
Definition: player.cpp:928
@ DT_CUT
Definition: damage.h:25
Definition: trap.h:86
std::string name() const
Definition: trap.cpp:177
bool can_see(const tripoint &pos, const Character &p) const
Can player/npc p see this kind of trap, either by their memory (they known there is the trap) or by t...
Definition: trap.cpp:223
bool is_benign() const
If true, this is not really a trap and there won't be any safety queries before stepping onto it (e....
Definition: trap.h:159

References bp_arm_l, bp_arm_r, bp_eyes, bp_foot_l, bp_foot_r, bp_hand_l, bp_hand_r, bp_head, bp_leg_l, bp_leg_r, bp_mouth, bp_torso, trap::can_see(), Character::dex_cur, DT_CUT, map::field_at(), Character::get_armor_bash(), map::has_flag(), map::has_zlevels(), player::immune_to(), Character::in_vehicle, trap::is_benign(), Character::is_blind(), Creature::is_dangerous_field(), trap::loadid, m, trap::name(), map::name(), optional_vpart_position::part_with_feature(), Character::pos(), map::tr_at(), tr_ledge, u, and map::veh_at().

Referenced by is_dangerous_tile(), prompt_dangerous_tile(), and walk_move().

◆ get_fishable_locations()

std::unordered_set< tripoint > game::get_fishable_locations ( int  distance,
const tripoint fish_pos 
)

Get the contiguous fishable locations starting at fish_pos, out to the specificed distance.

Parameters
distanceDistance around the fish_pos to examine for contiguous fishable locations.
fish_posThe location being fished.
Returns
A set of locations representing the valid contiguous fishable locations.

Definition at line 3755 of file game.cpp.

3756{
3757 // We're going to get the contiguous fishable terrain starting at
3758 // the provided fishing location (e.g. where a line was cast or a fish
3759 // trap was set), and then check whether or not fishable monsters are
3760 // actually in those locations. This will help us ensure that we're
3761 // getting our fish from the location that we're ACTUALLY fishing,
3762 // rather than just somewhere in the vicinity.
3763
3764 std::unordered_set<tripoint> visited;
3765
3766 const tripoint fishing_boundary_min( fish_pos + point( -distance, -distance ) );
3767 const tripoint fishing_boundary_max( fish_pos + point( distance, distance ) );
3768
3769 const inclusive_cuboid<tripoint> fishing_boundaries(
3770 fishing_boundary_min, fishing_boundary_max );
3771
3772 const auto get_fishable_terrain = [&]( tripoint starting_point,
3773 std::unordered_set<tripoint> &fishable_terrain ) {
3774 std::queue<tripoint> to_check;
3775 to_check.push( starting_point );
3776 while( !to_check.empty() ) {
3777 const tripoint current_point = to_check.front();
3778 to_check.pop();
3779
3780 // We've been here before, so bail.
3781 if( visited.find( current_point ) != visited.end() ) {
3782 continue;
3783 }
3784
3785 // This point is out of bounds, so bail.
3786 if( !fishing_boundaries.contains( current_point ) ) {
3787 continue;
3788 }
3789
3790 // Mark this point as visited.
3791 visited.emplace( current_point );
3792
3793 if( m.has_flag( "FISHABLE", current_point ) ) {
3794 fishable_terrain.emplace( current_point );
3795 to_check.push( current_point + point_south );
3796 to_check.push( current_point + point_north );
3797 to_check.push( current_point + point_east );
3798 to_check.push( current_point + point_west );
3799 }
3800 }
3801 return;
3802 };
3803
3804 // Starting at the provided location, get our fishable terrain
3805 // and populate a set with those locations which we'll then use
3806 // to determine if any fishable monsters are in those locations.
3807 std::unordered_set<tripoint> fishable_points;
3808 get_fishable_terrain( fish_pos, fishable_points );
3809
3810 return fishable_points;
3811}
static constexpr point point_west
Definition: point.h:282
static constexpr point point_south
Definition: point.h:280
static constexpr point point_north
Definition: point.h:276
static constexpr point point_east
Definition: point.h:278

References inclusive_cuboid< Tripoint, >::contains(), map::has_flag(), m, point_east, point_north, point_south, and point_west.

◆ get_fishable_monsters()

std::vector< monster * > game::get_fishable_monsters ( std::unordered_set< tripoint > &  fishable_locations)

Get the fishable monsters within the provided fishable locations.

Parameters
fishable_locationsA set of locations which are valid fishable terrain. Any fishable monsters are filtered by this collection to determine those which can actually be caught.
Returns
Fishable monsters within the specified fishable terrain.

Definition at line 3813 of file game.cpp.

3815{
3816 std::vector<monster *> unique_fish;
3817 for( monster &critter : all_monsters() ) {
3818 // If it is fishable...
3819 if( critter.has_flag( MF_FISHABLE ) ) {
3820 const tripoint critter_pos = critter.pos();
3821 // ...and it is in a fishable location.
3822 if( fishable_locations.find( critter_pos ) != fishable_locations.end() ) {
3823 unique_fish.push_back( &critter );
3824 }
3825 }
3826 }
3827
3828 return unique_fish;
3829}
@ MF_FISHABLE
Definition: mtype.h:142

References all_monsters(), and MF_FISHABLE.

◆ get_follower_list()

std::set< character_id > game::get_follower_list ( )

Get set of followers.

Definition at line 2075 of file game.cpp.

2076{
2077 return follower_ids;
2078}

References follower_ids.

◆ get_kill_tracker()

const kill_tracker & game::get_kill_tracker ( ) const

Definition at line 984 of file game.cpp.

985{
986 return *kill_tracker_ptr;
987}

References kill_tracker_ptr.

Referenced by cleanup_at_end(), death_screen(), handle_action(), and win().

◆ get_levx()

int game::get_levx ( ) const

The top left corner of the reality bubble (in submaps coordinates).

This is the same as map::abs_sub of the m map.

Definition at line 11973 of file game.cpp.

11974{
11975 return m.get_abs_sub().x;
11976}

References map::get_abs_sub(), m, and tripoint::x.

Referenced by create_starting_npcs(), load_npcs(), look_around(), save_cyborg(), spawn_hallucination(), vertical_move(), and vertical_shift().

◆ get_levy()

int game::get_levy ( ) const

Definition at line 11978 of file game.cpp.

11979{
11980 return m.get_abs_sub().y;
11981}

References map::get_abs_sub(), m, and tripoint::y.

Referenced by create_starting_npcs(), load_npcs(), look_around(), save_cyborg(), spawn_hallucination(), vertical_move(), and vertical_shift().

◆ get_levz()

◆ get_moves_since_last_save()

int game::get_moves_since_last_save ( ) const

Definition at line 7211 of file game.cpp.

7212{
7213 return moves_since_last_save;
7214}

References moves_since_last_save.

◆ get_npcs_if()

std::vector< npc * > game::get_npcs_if ( const std::function< bool(const npc &)> &  pred)

Definition at line 12020 of file game.cpp.

12021{
12022 std::vector<npc *> result;
12023 for( npc &guy : all_npcs() ) {
12024 if( pred( guy ) ) {
12025 result.push_back( &guy );
12026 }
12027 }
12028 return result;
12029}

References all_npcs().

Referenced by allies(), chat(), and validate_npc_followers().

◆ get_player_base_save_path()

std::string game::get_player_base_save_path ( ) const

Base path for saving player data.

Just add a suffix (unique for the thing you want to save) and use the resulting path. Example: save_ui_data(get_player_base_save_path()+".ui")

Definition at line 12108 of file game.cpp.

12109{
12110 return get_world_base_save_path() + "/" + base64_encode( u.name );
12111}
std::string base64_encode(const std::string &str)
std::string get_world_base_save_path() const
Base path for saving world data.
Definition: game.cpp:12113

References base64_encode(), get_world_base_save_path(), Character::name, and u.

Referenced by save_player_data().

◆ get_player_input()

input_context game::get_player_input ( std::string &  action)
private

Definition at line 239 of file handle_action.cpp.

240{
241 input_context ctxt;
242 if( uquit == QUIT_WATCH ) {
243 ctxt = input_context( "DEFAULTMODE" );
244 ctxt.set_iso( true );
245 // The list of allowed actions in death-cam mode in game::handle_action
246 // *INDENT-OFF*
247 for( const action_id id : {
260 } ) {
261 ctxt.register_action( action_ident( id ) );
262 }
263 // *INDENT-ON*
264 ctxt.register_action( "QUIT", to_translation( "Accept your fate" ) );
265 } else {
267 }
268
270
271 user_turn current_turn;
272
273
274 // Checking early if we will need to handle animations
275 // If we do not need to handle animations that will not change as long as the user has not selected an action
276 // and we can handle it like we are not animating.
277 weather_printable wPrint;
278 bool animate_weather = false;
279 bool animate_sct = false;
280 bool do_animations = [&]() {
281 if( get_option<bool>( "ANIMATIONS" ) ) {
282 const bool weather_has_anim = init_weather_anim( get_weather().weather_id, wPrint );
283
284 animate_weather = weather_has_anim && get_option<bool>( "ANIMATION_RAIN" );
285 animate_sct = !SCT.vSCT.empty() && uquit != QUIT_WATCH && get_option<bool>( "ANIMATION_SCT" );
286
287#if defined(TILES)
288 // Always animate, minimap and terrain may have animations to run
289 return true;
290#else
291 // Otherwise we need to see if we actually should animate.
292 // Minimap and Terrain never animate in !TILES
293 return animate_weather || animate_sct || uquit == QUIT_WATCH;
294#endif
295 }
296 return false;
297 }
298 ();
299
300 if( do_animations ) {
301 ctxt.set_timeout( 125 );
302
304 make_shared_fast<game::draw_callback_t>( [&]() {
305 if( animate_weather ) {
306 draw_weather( wPrint );
307 }
308 if( animate_sct ) {
309 draw_sct();
310 }
311 } );
312 add_draw_callback( animation_cb );
313 invalidate_main_ui_adaptor(); // We want to redraw at least once.
314
315 do {
316 if( animate_weather ) {
318 generate_weather_anim_frame( get_weather().weather_id, wPrint );
319 }
320 // don't bother calculating SCT if we won't show it
321 if( animate_sct ) {
323
325
326 //Check for creatures on all drawing positions and offset if necessary
327 for( auto iter = SCT.vSCT.rbegin(); iter != SCT.vSCT.rend(); ++iter ) {
328 const direction oCurDir = iter->getDirecton();
329 const int width = utf8_width( iter->getText() );
330 for( int i = 0; i < width; ++i ) {
331 tripoint tmp( iter->getPosX() + i, iter->getPosY(), get_levz() );
332 const Creature *critter = critter_at( tmp, true );
333
334 if( critter != nullptr && u.sees( *critter ) ) {
335 i = -1;
336 int iPos = iter->getStep() + iter->getStepOffset();
337 for( auto iter2 = iter; iter2 != SCT.vSCT.rend(); ++iter2 ) {
338 if( iter2->getDirecton() == oCurDir &&
339 iter2->getStep() + iter2->getStepOffset() <= iPos ) {
340 if( iter2->getType() == "hp" ) {
341 iter2->advanceStepOffset();
342 }
343
344 iter2->advanceStepOffset();
345 iPos = iter2->getStep() + iter2->getStepOffset();
346 }
347 }
348 }
349 }
350 }
351
352 // Stop animation when done
353 animate_sct = !SCT.vSCT.empty();
354 }
355 // We don't cache these checks as their result may change after 1st redraw
357 // TODO: we redraw *everything* just to animate a couple blinking dots
358 // on the minimap or a few tiles.
359 // This is far from ideal, and can probably be done much cheaper
360 // (update only part of the screen? draw static parts into a texture?)
362 }
363
364 std::unique_ptr<static_popup> deathcam_msg_popup;
365 if( uquit == QUIT_WATCH ) {
366 deathcam_msg_popup = std::make_unique<static_popup>();
367 deathcam_msg_popup
368 ->wait_message( c_red, _( "Press %s to accept your fate…" ), ctxt.get_desc( "QUIT" ) )
369 .on_top( true );
370 }
371
373 } while( handle_mouseview( ctxt, action ) && uquit != QUIT_WATCH
374 && ( action != "TIMEOUT" || !current_turn.has_timeout_elapsed() ) );
375 ctxt.reset_timeout();
376 } else {
379 SCT.vSCT.clear();
380
381 ctxt.set_timeout( 125 );
382 while( handle_mouseview( ctxt, action ) ) {
383 if( action == "TIMEOUT" && current_turn.has_timeout_elapsed() ) {
384 break;
385 }
386 }
387 ctxt.reset_timeout();
388 }
389
390 return ctxt;
391}
std::string action_ident(action_id act)
Lookup a unique string identifier for a given action ID.
Definition: action.cpp:68
action_id
Enumerates all discrete actions that can be performed by player.
Definition: action.h:22
@ ACTION_CENTER
Center the viewport on character.
Definition: action.h:77
@ ACTION_SHIFT_SW
Move viewport south-west.
Definition: action.h:89
@ ACTION_SHIFT_NW
Move viewport north-west.
Definition: action.h:93
@ ACTION_KEYBINDINGS
Display keybindings list.
Definition: action.h:257
@ ACTION_SHIFT_E
Move viewport east.
Definition: action.h:83
@ ACTION_TOGGLE_MAP_MEMORY
Toggle memorized tiles being shown.
Definition: action.h:75
@ ACTION_SHIFT_S
Move viewport south.
Definition: action.h:87
@ ACTION_SHIFT_SE
Move viewport south-east.
Definition: action.h:85
@ ACTION_LOOK
Toggle look mode.
Definition: action.h:119
@ ACTION_SHIFT_NE
Move viewport north-east.
Definition: action.h:81
@ ACTION_SHIFT_W
Move viewport west.
Definition: action.h:91
@ ACTION_SHIFT_N
Move viewport north.
Definition: action.h:79
bool terrain_requires_animation()
Definition: animation.cpp:1144
bool minimap_requires_animation()
Definition: animation.cpp:1135
void draw_sct()
Definition: animation.cpp:805
void draw_weather(const weather_printable &wPrint)
Definition: animation.cpp:764
void add_draw_callback(shared_ptr_fast< draw_callback_t > cb)
Definition: game.cpp:3168
bool handle_mouseview(input_context &ctxt, std::string &action)
Definition: game.cpp:2106
void set_timeout(int val)
Sets input polling timeout as appropriate for the current interface system.
Definition: input.cpp:1458
std::string get_desc(const std::string &action_descriptor, unsigned int max_limit=0, const input_event_filter &evt_filter=allow_all_keys) const
Get a description text for the key/other input method associated with the given action.
Definition: input.cpp:756
void register_action(const std::string &action_descriptor)
Register an action with this input context.
Definition: input.cpp:676
void set_iso(bool mode=true)
Definition: input.cpp:1429
void reset_timeout()
Definition: input.cpp:1463
std::vector< cSCT > vSCT
Definition: output.h:959
void advanceAllSteps()
Definition: output.cpp:1924
bool has_timeout_elapsed()
input_context get_default_mode_input_context()
Definition: game.cpp:2206
static bool init_weather_anim(const weather_type_id &wtype, weather_printable &wPrint)
static void generate_weather_anim_frame(const weather_type_id &wtype, weather_printable &wPrint)
direction
Definition: line.h:39
scrollingcombattext SCT
Definition: output.cpp:65
Weather drawing tracking.
Definition: weather.h:59
translation to_translation(const std::string &raw)
Shorthands for translation::to_translation.

References _, action, ACTION_CENTER, action_ident(), ACTION_KEYBINDINGS, ACTION_LOOK, ACTION_SHIFT_E, ACTION_SHIFT_N, ACTION_SHIFT_NE, ACTION_SHIFT_NW, ACTION_SHIFT_S, ACTION_SHIFT_SE, ACTION_SHIFT_SW, ACTION_SHIFT_W, ACTION_TOGGLE_MAP_MEMORY, add_draw_callback(), scrollingcombattext::advanceAllSteps(), c_red, critter_at(), draw_sct(), draw_weather(), generate_weather_anim_frame(), get_default_mode_input_context(), input_context::get_desc(), get_levz(), get_weather, handle_mouseview(), user_turn::has_timeout_elapsed(), init_weather_anim(), invalidate_main_ui_adaptor(), m, minimap_requires_animation(), Character::posz(), QUIT_WATCH, ui_manager::redraw_invalidated(), input_context::register_action(), input_context::reset_timeout(), SCT, Character::sees(), input_context::set_iso(), input_context::set_timeout(), terrain_requires_animation(), to_translation(), u, map::update_visibility_cache(), uquit, utf8_width(), and scrollingcombattext::vSCT.

Referenced by handle_action().

◆ get_seed()

unsigned int game::get_seed ( ) const

Definition at line 1887 of file game.cpp.

1888{
1889 return seed;
1890}

References seed.

◆ get_user_action_counter()

int game::get_user_action_counter ( ) const

Definition at line 7216 of file game.cpp.

7217{
7218 return user_action_counter;
7219}

References user_action_counter.

◆ get_veh_dir_indicator_location()

cata::optional< tripoint > game::get_veh_dir_indicator_location ( bool  next) const

Returns the location where the indicator should go relative to the reality bubble, or nothing to indicate no indicator should be drawn.

Based on the vehicle the player is driving, if any.

Parameters
nextIf true, bases it on the vehicle the vehicle will turn to next turn, instead of the one it is currently facing.

Definition at line 3423 of file game.cpp.

3424{
3425 if( !get_option<bool>( "VEHICLE_DIR_INDICATOR" ) ) {
3426 return cata::nullopt;
3427 }
3428 const optional_vpart_position vp = m.veh_at( u.pos() );
3429 if( !vp ) {
3430 return cata::nullopt;
3431 }
3432 vehicle *const veh = &vp->vehicle();
3433 rl_vec2d face = next ? veh->dir_vec() : veh->face_vec();
3434 float r = 10.0;
3435 return tripoint( static_cast<int>( r * face.x ), static_cast<int>( r * face.y ), u.pos().z );
3436}
rl_vec2d dir_vec() const

References vehicle::dir_vec(), vehicle::face_vec(), m, cata::nullopt, Character::pos(), u, map::veh_at(), rl_vec2d::x, rl_vec2d::y, and tripoint::z.

Referenced by draw_veh_dir_indicator().

◆ get_world_base_save_path()

std::string game::get_world_base_save_path ( ) const

Base path for saving world data.

This yields a path to a folder.

Definition at line 12113 of file game.cpp.

12114{
12115 if( world_generator->active_world == nullptr ) {
12116 return PATH_INFO::savedir();
12117 }
12118 return world_generator->active_world->folder_path();
12119}
std::string savedir()
Definition: path_info.cpp:254

References PATH_INFO::savedir(), and world_generator.

Referenced by get_player_base_save_path(), load(), load_master(), move_save_to_graveyard(), save(), save_artifacts(), and save_factions_missions_npcs().

◆ get_zoom()

int game::get_zoom ( ) const

Definition at line 7202 of file game.cpp.

7203{
7204#if defined(TILES)
7205 return tileset_zoom;
7206#else
7207 return DEFAULT_TILESET_ZOOM;
7208#endif
7209}

References DEFAULT_TILESET_ZOOM, and tileset_zoom.

Referenced by look_around().

◆ grabbed_furn_move()

bool game::grabbed_furn_move ( const tripoint dp)
private
Strength determines ability to drag furniture

Definition at line 9622 of file game.cpp.

9623{
9624 // Furniture: pull, push, or standing still and nudging object around.
9625 // Can push furniture out of reach.
9626 tripoint fpos = u.pos() + u.grab_point;
9627 // supposed position of grabbed furniture
9628 if( !m.has_furn( fpos ) ) {
9629 // Where did it go? We're grabbing thin air so reset.
9630 add_msg( m_info, _( "No furniture at grabbed point." ) );
9631 u.grab( OBJECT_NONE );
9632 return false;
9633 }
9634
9635 const bool pushing_furniture = dp == u.grab_point;
9636 const bool pulling_furniture = dp == -u.grab_point;
9637 const bool shifting_furniture = !pushing_furniture && !pulling_furniture;
9638
9639 tripoint fdest = fpos + dp; // intended destination of furniture.
9640 // Check floor: floorless tiles don't need to be flat and have no traps
9641 const bool has_floor = m.has_floor( fdest );
9642 // Unfortunately, game::is_empty fails for tiles we're standing on,
9643 // which will forbid pulling, so:
9644 const bool canmove = (
9645 m.passable( fdest ) &&
9646 critter_at<npc>( fdest ) == nullptr &&
9647 critter_at<monster>( fdest ) == nullptr &&
9648 ( !pulling_furniture || is_empty( u.pos() + dp ) ) &&
9649 ( !has_floor || m.has_flag( "FLAT", fdest ) ) &&
9650 !m.has_furn( fdest ) &&
9651 !m.veh_at( fdest ) &&
9652 ( !has_floor || m.tr_at( fdest ).is_null() )
9653 );
9654
9655 const furn_t furntype = m.furn( fpos ).obj();
9656 const int src_items = m.i_at( fpos ).size();
9657 const int dst_items = m.i_at( fdest ).size();
9658
9659 const bool only_liquid_items = std::all_of( m.i_at( fdest ).begin(), m.i_at( fdest ).end(),
9660 [&]( item & liquid_item ) {
9661 return liquid_item.made_of( LIQUID );
9662 } );
9663
9664 const bool dst_item_ok = !m.has_flag( "NOITEM", fdest ) &&
9665 !m.has_flag( "SWIMMABLE", fdest ) &&
9666 !m.has_flag( "DESTROY_ITEM", fdest );
9667
9668 const bool src_item_ok = m.furn( fpos ).obj().has_flag( "CONTAINER" ) ||
9669 m.furn( fpos ).obj().has_flag( "FIRE_CONTAINER" ) ||
9670 m.furn( fpos ).obj().has_flag( "SEALED" );
9671
9672 const int fire_intensity = m.get_field_intensity( fpos, fd_fire );
9673 time_duration fire_age = m.get_field_age( fpos, fd_fire );
9674
9675 int str_req = furntype.move_str_req;
9676 // Factor in weight of items contained in the furniture.
9677 units::mass furniture_contents_weight = 0_gram;
9678 for( auto &contained_item : m.i_at( fpos ) ) {
9679 furniture_contents_weight += contained_item.weight();
9680 }
9681 str_req += furniture_contents_weight / 4_kilogram;
9682 if( !canmove ) {
9683 // TODO: What is something?
9684 add_msg( _( "The %s collides with something." ), furntype.name() );
9685 u.moves -= 50;
9686 return true;
9687 ///\EFFECT_STR determines ability to drag furniture
9688 } else if( str_req > u.get_str() &&
9689 one_in( std::max( 20 - str_req - u.get_str(), 2 ) ) ) {
9690 add_msg( m_bad, _( "You strain yourself trying to move the heavy %s!" ),
9691 furntype.name() );
9692 u.moves -= 100;
9693 u.mod_pain( 1 ); // Hurt ourselves.
9694 return true; // furniture and or obstacle wins.
9695 } else if( !src_item_ok && !only_liquid_items && dst_items > 0 ) {
9696 add_msg( _( "There's stuff in the way." ) );
9697 u.moves -= 50;
9698 return true;
9699 }
9700
9701 u.moves -= str_req * 10;
9702 // Additional penalty if we can't comfortably move it.
9703 if( str_req > u.get_str() ) {
9704 int move_penalty = std::pow( str_req, 2.0 ) + 100.0;
9705 if( move_penalty <= 1000 ) {
9706 if( u.get_str() >= str_req - 3 ) {
9707 u.moves -= std::max( 3000, move_penalty * 10 );
9708 add_msg( m_bad, _( "The %s is really heavy!" ), furntype.name() );
9709 if( one_in( 3 ) ) {
9710 add_msg( m_bad, _( "You fail to move the %s." ), furntype.name() );
9711 return true;
9712 }
9713 } else {
9714 u.moves -= 100;
9715 add_msg( m_bad, _( "The %s is too heavy for you to budge." ), furntype.name() );
9716 return true;
9717 }
9718 }
9719 u.moves -= move_penalty;
9720 if( move_penalty > 500 ) {
9721 add_msg( _( "Moving the heavy %s is taking a lot of time!" ),
9722 furntype.name() );
9723 } else if( move_penalty > 200 ) {
9724 if( one_in( 3 ) ) { // Nag only occasionally.
9725 add_msg( _( "It takes some time to move the heavy %s." ),
9726 furntype.name() );
9727 }
9728 }
9729 }
9731 _( "a scraping noise." ), true, "misc", "scraping" );
9732
9734 ( tripoint_abs_ms( m.getabs( fpos ) ) );
9735
9736 // Actually move the furniture.
9737 m.furn_set( fdest, m.furn( fpos ), atd ? atd->clone() : nullptr );
9738 m.furn_set( fpos, f_null );
9739
9740 if( fire_intensity == 1 && !pulling_furniture ) {
9741 m.remove_field( fpos, fd_fire );
9742 m.set_field_intensity( fdest, fd_fire, fire_intensity );
9743 m.set_field_age( fdest, fd_fire, fire_age );
9744 }
9745
9746 // Is there is only liquids on the ground, remove them after moving furniture.
9747 if( dst_items > 0 && only_liquid_items ) {
9748 m.i_clear( fdest );
9749 }
9750
9751 if( src_items > 0 ) { // Move the stuff inside.
9752 if( dst_item_ok && src_item_ok ) {
9753 // Assume contents of both cells are legal, so we can just swap contents.
9754 std::list<item> temp;
9755 std::move( m.i_at( fpos ).begin(), m.i_at( fpos ).end(),
9756 std::back_inserter( temp ) );
9757 m.i_clear( fpos );
9758 for( auto item_iter = m.i_at( fdest ).begin();
9759 item_iter != m.i_at( fdest ).end(); ++item_iter ) {
9760 m.i_at( fpos ).insert( *item_iter );
9761 }
9762 m.i_clear( fdest );
9763 for( auto &cur_item : temp ) {
9764 m.i_at( fdest ).insert( cur_item );
9765 }
9766 } else {
9767 add_msg( _( "Stuff spills from the %s!" ), furntype.name() );
9768 }
9769 }
9770
9771 if( shifting_furniture ) {
9772 // We didn't move
9773 tripoint d_sum = u.grab_point + dp;
9774 if( std::abs( d_sum.x ) < 2 && std::abs( d_sum.y ) < 2 ) {
9775 u.grab_point = d_sum; // furniture moved relative to us
9776 } else { // we pushed furniture out of reach
9777 add_msg( _( "You let go of the %s." ), furntype.name() );
9778 u.grab( OBJECT_NONE );
9779 }
9780 return true; // We moved furniture but stayed still.
9781 }
9782
9783 if( pushing_furniture && m.impassable( fpos ) ) {
9784 // Not sure how that chair got into a wall, but don't let player follow.
9785 add_msg( _( "You let go of the %1$s as it slides past %2$s." ),
9786 furntype.name(), m.tername( fdest ) );
9787 u.grab( OBJECT_NONE );
9788 return true;
9789 }
9790
9791 return false;
9792}
virtual int get_str() const
Getters for stats exclusive to characters.
Definition: character.cpp:4064
virtual active_tile_data * clone() const =0
void grab(object_type grab_type, const tripoint &grab_point=tripoint_zero)
Definition: avatar.cpp:653
bool is_empty(const tripoint &p)
Returns true if there is no player, NPC, or monster on the tile and move_cost > 0.
Definition: game.cpp:4973
void insert(const item &newitem) override
Definition: map.cpp:157
void remove_field(const tripoint &p, const field_type_id &field_to_remove)
Remove field entry at xy, ignored if the field entry is not present.
Definition: map.cpp:5453
time_duration set_field_age(const tripoint &p, const field_type_id &type, const time_duration &age, bool isoffset=false)
Set age of field entry at point.
Definition: map.cpp:5327
time_duration get_field_age(const tripoint &p, const field_type_id &type) const
Get the age of a field entry (field_entry::age), if there is no field of that type,...
Definition: map.cpp:5361
int get_field_intensity(const tripoint &p, const field_type_id &type) const
Get the intensity of a field entry (field_entry::intensity), if there is no field of that type,...
Definition: map.cpp:5367
int set_field_intensity(const tripoint &p, const field_type_id &type, int new_intensity, bool isoffset=false)
Set intensity of field entry at point, creating if not present, removing if intensity becomes 0.
Definition: map.cpp:5340
std::string tername(const tripoint &p) const
Definition: map.cpp:1709
void i_clear(const tripoint &p)
Definition: map.cpp:4117
void furn_set(const tripoint &p, const furn_id &new_furniture, cata::poly_serialized< active_tile_data > new_active=nullptr)
Sets the furniture at given position.
Definition: map.cpp:1360
bool has_floor(const tripoint &p) const
Definition: map.cpp:2007
tripoint grab_point
Definition: player.h:591
coords::coord_point< tripoint, coords::origin::abs, coords::ms > tripoint_abs_ms
Definition: coordinates.h:486
@ OBJECT_NONE
Definition: enums.h:187
field_type_id fd_fire
Definition: field_type.cpp:345
furn_id f_null
Definition: mapdata.cpp:1095
template active_tile_data * furn_at< active_tile_data >(const tripoint_abs_ms &)
bool move(avatar &you, map &m, const tripoint &d)
void sound(const tripoint &p, int vol, sound_t category, const std::string &description, bool ambient=false, const std::string &id="", const std::string &variant="default")
Sound at (p) of intensity (vol)
Definition: sounds.cpp:177
int move_str_req
Definition: mapdata.h:511
bool has_flag(const std::string &flag) const
Definition: mapdata.h:415

References _, add_msg(), item_stack::begin(), active_tile_data::clone(), item_stack::end(), f_null, fd_fire, map::furn(), active_tiles::furn_at< active_tile_data >(), map::furn_set(), map::get_field_age(), map::get_field_intensity(), Character::get_str(), map::getabs(), avatar::grab(), player::grab_point, map_data_common_t::has_flag(), map::has_flag(), map::has_floor(), map::has_furn(), map::i_at(), map::i_clear(), map::impassable(), map_stack::insert(), is_empty(), trap::is_null(), m, m_bad, m_info, player::mod_pain(), avatar_action::move(), furn_t::move_str_req, sounds::movement, Creature::moves, map_data_common_t::name(), int_id< T >::obj(), OBJECT_NONE, one_in(), map::passable(), Character::pos(), map::remove_field(), map::set_field_age(), map::set_field_intensity(), item_stack::size(), sounds::sound(), map::tername(), map::tr_at(), u, map::veh_at(), tripoint::x, and tripoint::y.

Referenced by grabbed_move().

◆ grabbed_move()

bool game::grabbed_move ( const tripoint dp)
private

Check for dangerous stuff at dest_loc, return false if the player decides not to step there.

Definition at line 9794 of file game.cpp.

9795{
9796 if( u.get_grab_type() == OBJECT_NONE ) {
9797 return false;
9798 }
9799
9800 if( dp.z != 0 ) {
9801 // No dragging stuff up/down stairs yet!
9802 return false;
9803 }
9804
9805 // vehicle: pulling, pushing, or moving around the grabbed object.
9806 if( u.get_grab_type() == OBJECT_VEHICLE ) {
9807 return grabbed_veh_move( dp );
9808 }
9809
9810 if( u.get_grab_type() == OBJECT_FURNITURE ) {
9811 return grabbed_furn_move( dp );
9812 }
9813
9814 add_msg( m_info, _( "Nothing at grabbed point %d,%d,%d or bad grabbed object type." ),
9816 u.grab( OBJECT_NONE );
9817 return false;
9818}
object_type get_grab_type() const
Definition: avatar.cpp:661
bool grabbed_furn_move(const tripoint &dp)
Definition: game.cpp:9622
bool grabbed_veh_move(const tripoint &dp)
Definition: grab.cpp:21
@ OBJECT_FURNITURE
Definition: enums.h:197
@ OBJECT_VEHICLE
Definition: enums.h:193

References _, add_msg(), avatar::get_grab_type(), avatar::grab(), player::grab_point, grabbed_furn_move(), grabbed_veh_move(), m_info, OBJECT_FURNITURE, OBJECT_NONE, OBJECT_VEHICLE, u, tripoint::x, tripoint::y, and tripoint::z.

Referenced by walk_move().

◆ grabbed_veh_move()

bool game::grabbed_veh_move ( const tripoint dp)
private
Strength determines ability to drag vehicles Strength increases speed of dragging vehicles

Definition at line 21 of file grab.cpp.

22{
23 const optional_vpart_position grabbed_vehicle_vp = m.veh_at( u.pos() + u.grab_point );
24 if( !grabbed_vehicle_vp ) {
25 add_msg( m_info, _( "No vehicle at grabbed point." ) );
27 return false;
28 }
29 vehicle *grabbed_vehicle = &grabbed_vehicle_vp->vehicle();
30 if( !grabbed_vehicle ||
31 !grabbed_vehicle->handle_potential_theft( dynamic_cast<player &>( g->u ) ) ) {
32 return false;
33 }
34 const int grabbed_part = grabbed_vehicle_vp->part_index();
35 for( int part_index = 0; part_index < grabbed_vehicle->part_count(); ++part_index ) {
36 monster *mon = grabbed_vehicle->get_pet( part_index );
37 if( mon != nullptr && mon->has_effect( effect_harnessed ) ) {
38 add_msg( m_info, _( "You cannot move this vehicle whilst your %s is harnessed!" ),
39 mon->get_name() );
41 return false;
42 }
43 }
44 const vehicle *veh_under_player = veh_pointer_or_null( m.veh_at( u.pos() ) );
45 if( grabbed_vehicle == veh_under_player ) {
46 u.grab_point = -dp;
47 return false;
48 }
49
50 tripoint dp_veh = -u.grab_point;
51 const tripoint prev_grab = u.grab_point;
52 tripoint next_grab = u.grab_point;
53
54 bool zigzag = false;
55
56 if( dp == prev_grab ) {
57 // We are pushing in the direction of vehicle
58 dp_veh = dp;
59 } else if( std::abs( dp.x + dp_veh.x ) != 2 && std::abs( dp.y + dp_veh.y ) != 2 ) {
60 // Not actually moving the vehicle, don't do the checks
61 u.grab_point = -( dp + dp_veh );
62 return false;
63 } else if( ( dp.x == prev_grab.x || dp.y == prev_grab.y ) &&
64 next_grab.x != 0 && next_grab.y != 0 ) {
65 // Zig-zag (or semi-zig-zag) pull: player is diagonal to vehicle
66 // and moves away from it, but not directly away
67 dp_veh.x = dp.x == -dp_veh.x ? 0 : dp_veh.x;
68 dp_veh.y = dp.y == -dp_veh.y ? 0 : dp_veh.y;
69
70 next_grab = -dp_veh;
71 zigzag = true;
72 } else {
73 // We are pulling the vehicle
74 next_grab = -dp;
75 }
76
77 // Make sure the mass and pivot point are correct
78 grabbed_vehicle->invalidate_mass();
79
80 //vehicle movement: strength check
81 int mc = 0;
82 int str_req = grabbed_vehicle->total_mass() / 25_kilogram; //strength required to move vehicle.
83
84 //if vehicle is rollable we modify str_req based on a function of movecost per wheel.
85
86 // Vehicle just too big to grab & move; 41-45 lets folks have a bit of a window
87 // (Roughly 1.1K kg = danger zone; cube vans are about the max)
88 if( str_req > 45 ) {
89 add_msg( m_info, _( "The %s is too bulky for you to move by hand." ),
90 grabbed_vehicle->name );
91 return true; // No shoving around an RV.
92 }
93
94 const auto &wheel_indices = grabbed_vehicle->wheelcache;
95 if( grabbed_vehicle->valid_wheel_config() ) {
96 //determine movecost for terrain touching wheels
97 const tripoint vehpos = grabbed_vehicle->global_pos3();
98 for( int p : wheel_indices ) {
99 const tripoint wheel_pos = vehpos + grabbed_vehicle->part( p ).precalc[0];
100 const int mapcost = m.move_cost( wheel_pos, grabbed_vehicle );
101 mc += str_req / wheel_indices.size() * mapcost;
102 }
103 //set strength check threshold
104 //if vehicle has many or only one wheel (shopping cart), it is as if it had four.
105 if( wheel_indices.size() > 4 || wheel_indices.size() == 1 ) {
106 str_req = mc / 4 + 1;
107 } else {
108 str_req = mc / wheel_indices.size() + 1;
109 }
110 } else {
111 str_req++;
112 //if vehicle has no wheels str_req make a noise.
113 if( str_req <= u.get_str() ) {
114 sounds::sound( grabbed_vehicle->global_pos3(), str_req * 2, sounds::sound_t::movement,
115 _( "a scraping noise." ), true, "misc", "scraping" );
116 }
117 }
118
119 //final strength check and outcomes
120 ///\EFFECT_STR determines ability to drag vehicles
121 if( str_req <= u.get_str() ) {
122 //calculate exertion factor and movement penalty
123 ///\EFFECT_STR increases speed of dragging vehicles
124 u.moves -= 100 * str_req / std::max( 1, u.get_str() );
125 const int ex = dice( 1, 3 ) - 1 + str_req;
126 if( ex > u.get_str() + 1 ) {
127 // Pain and movement penalty if exertion exceeds character strength
128 add_msg( m_bad, _( "You strain yourself to move the %s!" ), grabbed_vehicle->name );
129 u.moves -= 200;
130 u.mod_pain( 1 );
131 } else if( ex >= u.get_str() ) {
132 // Movement is slow if exertion nearly equals character strength
133 add_msg( _( "It takes some time to move the %s." ), grabbed_vehicle->name );
134 u.moves -= 200;
135 }
136 } else {
137 u.moves -= 100;
138 add_msg( m_bad, _( "You lack the strength to move the %s" ), grabbed_vehicle->name );
139 return true;
140 }
141
142 std::string blocker_name = _( "errors in movement code" );
143 const auto get_move_dir = [&]( const tripoint & dir, const tripoint & from ) {
144 tileray mdir;
145
146 mdir.init( dir.xy() );
147 grabbed_vehicle->turn( mdir.dir() - grabbed_vehicle->face.dir() );
148 grabbed_vehicle->face = grabbed_vehicle->turn_dir;
149 grabbed_vehicle->precalc_mounts( 1, mdir.dir(), grabbed_vehicle->pivot_point() );
150
151 // Grabbed part has to stay at distance 1 to the player
152 // and in roughly the same direction.
153 const tripoint new_part_pos = grabbed_vehicle->global_pos3() +
154 grabbed_vehicle->part( grabbed_part ).precalc[ 1 ];
155 const tripoint expected_pos = u.pos() + dp + from;
156 const tripoint actual_dir = expected_pos - new_part_pos;
157
158 grabbed_vehicle->adjust_zlevel( 1, dp );
159
160 // Set player location to illegal value so it can't collide with vehicle.
161 const tripoint player_prev = u.pos();
163 std::vector<veh_collision> colls;
164 const bool failed = grabbed_vehicle->collision( colls, actual_dir, true );
165 u.setpos( player_prev );
166 if( !colls.empty() ) {
167 blocker_name = colls.front().target_name;
168 }
169 return failed ? tripoint_zero : actual_dir;
170 };
171
172 // First try the move as intended
173 // But if that fails and the move is a zig-zag, try to recover:
174 // Try to place the vehicle in the position player just left rather than "flattening" the zig-zag
175 tripoint final_dp_veh = get_move_dir( dp_veh, next_grab );
176 if( final_dp_veh == tripoint_zero && zigzag ) {
177 final_dp_veh = get_move_dir( -prev_grab, -dp );
178 next_grab = -dp;
179 }
180
181 if( final_dp_veh == tripoint_zero ) {
182 add_msg( _( "The %s collides with %s." ), grabbed_vehicle->name, blocker_name );
183 u.grab_point = prev_grab;
184 return true;
185 }
186
187 u.grab_point = next_grab;
188
189 m.displace_vehicle( *grabbed_vehicle, final_dp_veh );
190
191 if( grabbed_vehicle ) {
192 grabbed_vehicle->shift_zlevel();
193 grabbed_vehicle->check_falling_or_floating();
194 } else {
195 debugmsg( "Grabbed vehicle disappeared" );
196 return false;
197 }
198
199 for( int p : wheel_indices ) {
200 if( one_in( 2 ) ) {
201 tripoint wheel_p = grabbed_vehicle->global_part_pos3( grabbed_part );
202 grabbed_vehicle->handle_trap( wheel_p, p );
203 }
204 }
205
206 return false;
207
208}
bool displace_vehicle(vehicle &veh, const tripoint &dp)
Definition: map.cpp:1119
int move_cost(const tripoint &p, const vehicle *ignored_vehicle=nullptr) const
Calculate the cost to move past the tile at p.
Definition: map.cpp:1780
units::angle dir() const
Definition: tileray.cpp:74
void init(const point &ad)
Definition: tileray.cpp:27
void turn(units::angle deg)
const point & pivot_point() const
Definition: vehicle.cpp:5826
void adjust_zlevel(int idir=0, const tripoint &offset=tripoint_zero)
tripoint global_pos3() const
Definition: vehicle.cpp:3281
void precalc_mounts(int idir, units::angle dir, const point &pivot)
Definition: vehicle.cpp:3150
bool valid_wheel_config() const
Definition: vehicle.cpp:4459
units::mass total_mass() const
Definition: vehicle.cpp:3306
std::vector< int > wheelcache
Definition: vehicle.h:1818
void check_falling_or_floating()
tileray face
Definition: vehicle.h:1948
void invalidate_mass()
Mark mass caches and pivot cache as dirty.
Definition: vehicle.cpp:6968
int part_count() const
Definition: vehicle.cpp:7075
bool collision(std::vector< veh_collision > &colls, const tripoint &dp, bool just_detect, bool bash_floor=false)
monster * get_pet(int p) const
Definition: vehicle.cpp:3262
vehicle_part & part(int part_num)
Definition: vehicle.cpp:7080
void handle_trap(const tripoint &p, int part)
tripoint global_part_pos3(const int &index) const
Get the coordinates of the studied part of the vehicle.
Definition: vehicle.cpp:3286
void shift_zlevel()
units::angle turn_dir
Definition: vehicle.h:1927
static const efftype_id effect_harnessed("harnessed")
static constexpr tripoint tripoint_zero
Definition: point.h:273
int dice(int number, int sides)
Definition: rng.cpp:85
std::array< tripoint, 2 > precalc
mount translated to face.dir [0] and turn_dir [1]
Definition: vehicle.h:371

References _, add_msg(), vehicle::adjust_zlevel(), vehicle::check_falling_or_floating(), vehicle::collision(), debugmsg, dice(), tileray::dir(), map::displace_vehicle(), effect_harnessed, vehicle::face, failed, g, monster::get_name(), vehicle::get_pet(), Character::get_str(), vehicle::global_part_pos3(), vehicle::global_pos3(), avatar::grab(), player::grab_point, vehicle::handle_potential_theft(), vehicle::handle_trap(), Creature::has_effect(), tileray::init(), vehicle::invalidate_mass(), m, m_bad, m_info, player::mod_pain(), map::move_cost(), sounds::movement, Creature::moves, vehicle::name, OBJECT_NONE, one_in(), vehicle::part(), vehicle::part_count(), vehicle::pivot_point(), Character::pos(), vehicle_part::precalc, vehicle::precalc_mounts(), Character::setpos(), vehicle::shift_zlevel(), sounds::sound(), vehicle::total_mass(), tripoint_zero, vehicle::turn(), vehicle::turn_dir, u, vehicle::valid_wheel_config(), map::veh_at(), veh_pointer_or_null(), vehicle::wheelcache, tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by grabbed_move().

◆ handle_action()

bool game::handle_action ( )
private

Definition at line 1515 of file handle_action.cpp.

1516{
1517 std::string action;
1518 input_context ctxt;
1520 user_turn current_turn;
1521 // Check if we have an auto-move destination
1522 if( u.has_destination() ) {
1524 if( act == ACTION_NULL ) {
1525 add_msg( m_info, _( "Auto-move canceled" ) );
1527 return false;
1528 }
1529 } else if( u.has_destination_activity() ) {
1530 // starts destination activity after the player successfully reached his destination
1532 return false;
1533 } else {
1534 // No auto-move, ask player for input
1535 ctxt = get_player_input( action );
1536 }
1537
1538 const optional_vpart_position vp = m.veh_at( u.pos() );
1539 bool veh_ctrl = !u.is_dead_state() &&
1540 ( ( vp && vp->vehicle().player_in_control( u ) ) || remoteveh() != nullptr );
1541
1542 // If performing an action with right mouse button, co-ordinates
1543 // of location clicked.
1544 cata::optional<tripoint> mouse_target;
1545
1546 if( uquit == QUIT_WATCH && action == "QUIT" ) {
1547 uquit = QUIT_DIED;
1548 return false;
1549 }
1550
1551 if( act == ACTION_NULL ) {
1553
1554 if( act == ACTION_KEYBINDINGS ) {
1555 // already handled by input context
1556 return false;
1557 }
1558
1559 if( act == ACTION_MAIN_MENU ) {
1560 if( uquit == QUIT_WATCH ) {
1561 return false;
1562 }
1563 // No auto-move actions have or can be set at this point.
1565 destination_preview.clear();
1567 if( act == ACTION_NULL ) {
1568 return false;
1569 }
1570 }
1571
1572 if( act == ACTION_ACTIONMENU ) {
1573 if( uquit == QUIT_WATCH ) {
1574 return false;
1575 }
1576 // No auto-move actions have or can be set at this point.
1578 destination_preview.clear();
1580 if( act == ACTION_NULL ) {
1581 return false;
1582 }
1583#if defined(__ANDROID__)
1584 if( get_option<bool>( "ANDROID_ACTIONMENU_AUTOADD" ) && ctxt.get_category() == "DEFAULTMODE" ) {
1585 add_best_key_for_action_to_quick_shortcuts( act, ctxt.get_category(), false );
1586 }
1587#endif
1588 }
1589
1590 if( act == ACTION_KEYBINDINGS ) {
1592 destination_preview.clear();
1593 act = ctxt.display_menu( true );
1594 if( act == ACTION_NULL ) {
1595 return false;
1596 }
1597 }
1598
1601 }
1602
1603 if( act == ACTION_SELECT || act == ACTION_SEC_SELECT ) {
1604 // Mouse button click
1605 if( veh_ctrl ) {
1606 // No mouse use in vehicle
1607 return false;
1608 }
1609
1610 if( u.is_dead_state() ) {
1611 // do not allow mouse actions while dead
1612 return false;
1613 }
1614
1615 const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
1616 if( !mouse_pos ) {
1617 return false;
1618 } else if( !u.sees( *mouse_pos ) ) {
1619 // Not clicked in visible terrain
1620 return false;
1621 }
1622 mouse_target = mouse_pos;
1623
1624 if( act == ACTION_SELECT ) {
1625 // Note: The following has the potential side effect of
1626 // setting auto-move destination state in addition to setting
1627 // act.
1628 if( !try_get_left_click_action( act, *mouse_target ) ) {
1629 return false;
1630 }
1631 } else if( act == ACTION_SEC_SELECT ) {
1632 if( !try_get_right_click_action( act, *mouse_target ) ) {
1633 return false;
1634 }
1635 }
1636 } else if( act != ACTION_TIMEOUT ) {
1637 // act has not been set for an auto-move, so clearing possible
1638 // auto-move destinations. Since initializing an auto-move with
1639 // the mouse may span across multiple actions, we do not clear the
1640 // auto-move destination if the action is only a timeout, as this
1641 // would require the user to double click quicker than the
1642 // timeout delay.
1644 destination_preview.clear();
1645 }
1646 }
1647
1648 if( act == ACTION_NULL ) {
1649 const input_event &&evt = ctxt.get_raw_input();
1650 if( !evt.sequence.empty() ) {
1651 const int ch = evt.get_first_input();
1652 const std::string &&name = inp_mngr.get_keyname( ch, evt.type, true );
1653 if( !get_option<bool>( "NO_UNKNOWN_COMMAND_MSG" ) ) {
1654 add_msg( m_info, _( "Unknown command: \"%s\" (%ld)" ), name, ch );
1655 if( const cata::optional<std::string> hint =
1657 add_msg( m_info, _( "%s at any time to see and edit keybindings relevant to "
1658 "the current context." ),
1659 *hint );
1660 }
1661 }
1662 }
1663 return false;
1664 }
1665
1666 // This has no action unless we're in a special game mode.
1667 gamemode->pre_action( act );
1668
1669 int soffset = get_option<int>( "MOVE_VIEW_OFFSET" );
1670
1671 int before_action_moves = u.moves;
1672
1673 // These actions are allowed while deathcam is active. Registered in game::get_player_input
1674 if( uquit == QUIT_WATCH || !u.is_dead_state() ) {
1675 switch( act ) {
1678 break;
1679
1680 case ACTION_CENTER:
1683 break;
1684
1685 case ACTION_SHIFT_N:
1686 case ACTION_SHIFT_NE:
1687 case ACTION_SHIFT_E:
1688 case ACTION_SHIFT_SE:
1689 case ACTION_SHIFT_S:
1690 case ACTION_SHIFT_SW:
1691 case ACTION_SHIFT_W:
1692 case ACTION_SHIFT_NW: {
1693 static const std::map<action_id, std::pair<point, point>> shift_delta = {
1702 };
1704 shift_delta.at( act ).second * soffset : shift_delta.at( act ).first * soffset;
1705 }
1706 break;
1707
1708 case ACTION_LOOK:
1709 look_around();
1710 break;
1711
1712 case ACTION_KEYBINDINGS:
1713 // already handled by input context
1714 break;
1715
1716 default:
1717 break;
1718 }
1719 }
1720
1721 // actions allowed only while alive
1722 if( !u.is_dead_state() ) {
1723 switch( act ) {
1724 case ACTION_NULL:
1725 case NUM_ACTIONS:
1726 break; // dummy entries
1727 case ACTION_ACTIONMENU:
1728 case ACTION_MAIN_MENU:
1729 case ACTION_KEYBINDINGS:
1730 break; // handled above
1731
1732 case ACTION_TIMEOUT:
1733 if( check_safe_mode_allowed( false ) ) {
1734 u.pause();
1735 }
1736 break;
1737
1738 case ACTION_PAUSE:
1739 if( check_safe_mode_allowed() ) {
1740 u.pause();
1741 }
1742 break;
1743
1744 case ACTION_CYCLE_MOVE:
1746 break;
1747
1748 case ACTION_RESET_MOVE:
1750 break;
1751
1752 case ACTION_TOGGLE_RUN:
1754 break;
1755
1758 break;
1759
1762 break;
1763
1764 case ACTION_MOVE_FORTH:
1766 case ACTION_MOVE_RIGHT:
1768 case ACTION_MOVE_BACK:
1770 case ACTION_MOVE_LEFT:
1772 if( !u.get_value( "remote_controlling" ).empty() &&
1776 } else if( veh_ctrl ) {
1777 // vehicle control uses x for steering and y for ac/deceleration,
1778 // so no rotation needed
1780 } else {
1782 if( auto_travel_mode && !u.is_auto_moving() ) {
1783 for( int i = 0; i < SEEX; i++ ) {
1784 tripoint auto_travel_destination( u.posx() + dest_delta.x * ( SEEX - i ),
1785 u.posy() + dest_delta.y * ( SEEX - i ),
1786 u.posz() );
1788 auto_travel_destination,
1790 u.get_path_avoid() );
1791 if( !destination_preview.empty() ) {
1794 break;
1795 }
1796 }
1799 if( dest_next == point_zero ) {
1801 }
1802 dest_delta = dest_next;
1803 }
1804 if( !avatar_action::move( u, m, dest_delta ) ) {
1805 // auto-move should be canceled due to a failed move or obstacle
1807 }
1808 }
1809 break;
1810 case ACTION_MOVE_DOWN:
1811 if( u.is_mounted() ) {
1812 auto mon = u.mounted_creature.get();
1813 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1814 add_msg( m_info, _( "You can't go down stairs while you're riding." ) );
1815 break;
1816 }
1817 }
1818 if( !u.in_vehicle ) {
1819 vertical_move( -1, false );
1820 } else if( veh_ctrl && vp->vehicle().is_rotorcraft() ) {
1822 }
1823 break;
1824
1825 case ACTION_MOVE_UP:
1826 if( u.is_mounted() ) {
1827 auto mon = u.mounted_creature.get();
1828 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1829 add_msg( m_info, _( "You can't go down stairs while you're riding." ) );
1830 break;
1831 }
1832 }
1833 if( !u.in_vehicle ) {
1834 vertical_move( 1, false );
1835 } else if( veh_ctrl && vp->vehicle().is_rotorcraft() ) {
1837 } else if( veh_ctrl && vp->vehicle().has_part( "ROTOR" ) &&
1838 !vp->vehicle().has_sufficient_rotorlift() ) {
1839 add_msg( m_bad, _( "The rotors struggle to generate enough lift!" ) );
1840 }
1841 break;
1842
1843 case ACTION_OPEN:
1845 add_msg( m_info, _( "You can't open things while you're in your shell." ) );
1846 } else if( u.is_mounted() ) {
1847 add_msg( m_info, _( "You can't open things while you're riding." ) );
1848 } else {
1849 open();
1850 }
1851 break;
1852
1853 case ACTION_CLOSE:
1855 add_msg( m_info, _( "You can't close things while you're in your shell." ) );
1856 } else if( u.is_mounted() ) {
1857 auto mon = u.mounted_creature.get();
1858 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1859 add_msg( m_info, _( "You can't close things while you're riding." ) );
1860 }
1861 } else if( mouse_target ) {
1862 doors::close_door( m, u, *mouse_target );
1863 } else {
1864 close();
1865 }
1866 break;
1867
1868 case ACTION_SMASH:
1869 if( veh_ctrl ) {
1870 handbrake();
1871 } else if( u.has_active_mutation( trait_SHELL2 ) ) {
1872 add_msg( m_info, _( "You can't smash things while you're in your shell." ) );
1873 } else {
1874 smash();
1875 }
1876 break;
1877
1878 case ACTION_EXAMINE:
1880 add_msg( m_info, _( "You can't examine your surroundings while you're in your shell." ) );
1881 } else if( mouse_target ) {
1882 examine( *mouse_target );
1883 } else {
1884 examine();
1885 }
1886 break;
1887
1888 case ACTION_ADVANCEDINV:
1890 add_msg( m_info, _( "You can't move mass quantities while you're in your shell." ) );
1891 } else if( u.is_mounted() ) {
1892 add_msg( m_info, _( "You can't move mass quantities while you're riding." ) );
1893 } else {
1895 }
1896 break;
1897
1898 case ACTION_PICKUP:
1900 add_msg( m_info, _( "You can't pick anything up while you're in your shell." ) );
1901 } else if( u.is_mounted() ) {
1902 add_msg( m_info, _( "You can't pick anything up while you're riding." ) );
1903 } else if( mouse_target ) {
1904 pickup( *mouse_target );
1905 } else {
1906 pickup();
1907 }
1908 break;
1909
1910 case ACTION_PICKUP_FEET:
1912 add_msg( m_info, _( "You can't pick anything up while you're in your shell." ) );
1913 } else {
1914 pickup_feet();
1915 }
1916 break;
1917
1918 case ACTION_GRAB:
1920 add_msg( m_info, _( "You can't grab things while you're in your shell." ) );
1921 } else if( u.is_mounted() ) {
1922 add_msg( m_info, _( "You can't grab things while you're riding." ) );
1923 } else {
1924 grab();
1925 }
1926 break;
1927
1928 case ACTION_HAUL:
1930 add_msg( m_info, _( "You can't haul things while you're in your shell." ) );
1931 } else if( u.is_mounted() ) {
1932 add_msg( m_info, _( "You can't haul things while you're riding." ) );
1933 } else {
1934 haul();
1935 }
1936 break;
1937
1938 case ACTION_BUTCHER:
1940 add_msg( m_info, _( "You can't butcher while you're in your shell." ) );
1941 } else if( u.is_mounted() ) {
1942 add_msg( m_info, _( "You can't butcher while you're riding." ) );
1943 } else {
1944 butcher();
1945 }
1946 break;
1947
1948 case ACTION_CHAT:
1949 chat();
1950 break;
1951
1952 case ACTION_PEEK:
1954 add_msg( m_info, _( "You can't peek around corners while you're in your shell." ) );
1955 } else if( u.is_mounted() ) {
1956 add_msg( m_info, _( "You can't peek around corners while you're riding." ) );
1957 } else {
1958 peek();
1959 }
1960 break;
1961
1962 case ACTION_LIST_ITEMS:
1964 break;
1965
1966 case ACTION_ZONES:
1967 zones_manager();
1968 break;
1969
1970 case ACTION_LOOT:
1971 loot();
1972 break;
1973
1974 case ACTION_INVENTORY:
1976 break;
1977
1978 case ACTION_COMPARE:
1980 break;
1981
1982 case ACTION_ORGANIZE:
1984 break;
1985
1986 case ACTION_USE:
1987 // Shell-users are presumed to be able to mess with their inventories, etc
1988 // while in the shell. Eating, gear-changing, and item use are OK.
1990 break;
1991
1992 case ACTION_USE_WIELDED:
1993 u.use_wielded();
1994 break;
1995
1996 case ACTION_WEAR:
1997 wear();
1998 break;
1999
2000 case ACTION_TAKE_OFF:
2001 takeoff();
2002 break;
2003
2004 case ACTION_EAT:
2005 if( !avatar_action::eat_here( u ) ) {
2007 }
2008 break;
2009
2011 if( !avatar_action::eat_here( u ) ) {
2013 }
2014 break;
2015
2016 case ACTION_READ:
2017 // Shell-users are presumed to have the book just at an opening and read it that way
2018 read();
2019 break;
2020
2021 case ACTION_WIELD:
2023 break;
2024
2025 case ACTION_PICK_STYLE:
2026 u.martial_arts_data->pick_style( u );
2027 break;
2028
2029 case ACTION_RELOAD_ITEM:
2031 break;
2032
2035 break;
2036
2039 break;
2040
2041 case ACTION_UNLOAD:
2043 break;
2044
2045 case ACTION_MEND:
2047 break;
2048
2049 case ACTION_THROW: {
2050 item_location loc;
2051 avatar_action::plthrow( g->u, loc );
2052 break;
2053 }
2054
2055 case ACTION_FIRE:
2056 fire();
2057 break;
2058
2059 case ACTION_CAST_SPELL:
2060 cast_spell();
2061 break;
2062
2063 case ACTION_FIRE_BURST: {
2064 if( u.weapon.gun_set_mode( gun_mode_id( "AUTO" ) ) ) {
2066 }
2067 break;
2068 }
2069
2071 if( u.is_armed() && u.weapon.is_gun() && !u.weapon.is_gunmod() ) {
2072 if( u.weapon.gun_all_modes().size() > 1 ) {
2074 } else {
2075 add_msg( m_info, _( "Your %s has only one firing mode." ), u.weapon.display_name() );
2076 }
2077 }
2078 break;
2079
2081 if( u.is_armed() && u.weapon.is_gun() && !u.weapon.is_gunmod() ) {
2083 }
2084 break;
2085
2086 case ACTION_DROP:
2087 // You CAN drop things to your own tile while in the shell.
2088 drop();
2089 break;
2090
2091 case ACTION_DIR_DROP:
2093 add_msg( m_info, _( "You can't drop things to another tile while you're in your shell." ) );
2094 } else {
2096 }
2097 break;
2098 case ACTION_BIONICS:
2099 u.power_bionics();
2100 break;
2101 case ACTION_MUTATIONS:
2103 break;
2104
2105 case ACTION_SORT_ARMOR:
2106 u.sort_armor();
2107 break;
2108
2109 case ACTION_WAIT:
2110 wait();
2111 break;
2112
2113 case ACTION_CRAFT:
2115 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2116 } else if( u.is_mounted() ) {
2117 add_msg( m_info, _( "You can't craft while you're riding." ) );
2118 } else {
2119 u.craft();
2120 }
2121 break;
2122
2123 case ACTION_RECRAFT:
2125 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2126 } else if( u.is_mounted() ) {
2127 add_msg( m_info, _( "You can't craft while you're riding." ) );
2128 } else {
2129 u.recraft();
2130 }
2131 break;
2132
2133 case ACTION_LONGCRAFT:
2135 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2136 } else if( u.is_mounted() ) {
2137 add_msg( m_info, _( "You can't craft while you're riding." ) );
2138 } else {
2139 u.long_craft();
2140 }
2141 break;
2142
2143 case ACTION_DISASSEMBLE:
2144 if( u.controlling_vehicle ) {
2145 add_msg( m_info, _( "You can't disassemble items while driving." ) );
2146 } else if( u.is_mounted() ) {
2147 add_msg( m_info, _( "You can't disassemble items while you're riding." ) );
2148 } else {
2150 }
2151 break;
2152
2153 case ACTION_CONSTRUCT:
2154 if( u.in_vehicle ) {
2155 add_msg( m_info, _( "You can't construct while in a vehicle." ) );
2156 } else if( u.has_active_mutation( trait_SHELL2 ) ) {
2157 add_msg( m_info, _( "You can't construct while you're in your shell." ) );
2158 } else if( u.is_mounted() ) {
2159 add_msg( m_info, _( "You can't construct while you're riding." ) );
2160 } else {
2161 construction_menu( false );
2162 }
2163 break;
2164
2165 case ACTION_SLEEP:
2166 if( veh_ctrl ) {
2167 add_msg( m_info, _( "Vehicle control has moved, %s" ),
2168 press_x( ACTION_CONTROL_VEHICLE, _( "new binding is " ),
2169 _( "new default binding is '^'." ) ) );
2170 } else {
2171 sleep();
2172 }
2173 break;
2174
2177 add_msg( m_info, _( "You can't operate a vehicle while you're in your shell." ) );
2178 } else if( u.is_mounted() ) {
2179 u.dismount();
2180 } else {
2182 }
2183 break;
2184
2187 add_msg( m_info, auto_travel_mode ? _( "Auto travel mode ON!" ) : _( "Auto travel mode OFF!" ) );
2188 break;
2189
2191 if( safe_mode == SAFE_MODE_OFF ) {
2193 mostseen = 0;
2194 add_msg( m_info, _( "Safe mode ON!" ) );
2195 } else {
2198 add_msg( m_info, get_option<bool>( "AUTOSAFEMODE" )
2199 ? _( "Safe mode OFF! (Auto safe mode still enabled!)" ) : _( "Safe mode OFF!" ) );
2200 }
2204 }
2205 break;
2206
2208 auto &autosafemode_option = get_options().get_option( "AUTOSAFEMODE" );
2209 add_msg( m_info, autosafemode_option.value_as<bool>()
2210 ? _( "Auto safe mode OFF!" ) : _( "Auto safe mode ON!" ) );
2211 autosafemode_option.setNext();
2212 break;
2213 }
2214
2216 if( safe_mode == SAFE_MODE_STOP ) {
2217 add_msg( m_info, _( "Ignoring enemy!" ) );
2218 for( auto &elem : u.get_mon_visible().new_seen_mon ) {
2219 monster &critter = *elem;
2220 critter.ignoring = rl_dist( u.pos(), critter.pos() );
2221 }
2223 } else if( u.has_effect( effect_laserlocked ) ) {
2224 if( u.has_trait( trait_PROF_CHURL ) ) {
2225 add_msg( m_warning, _( "You make the sign of the cross." ) );
2226 } else {
2227 add_msg( m_info, _( "Ignoring laser targeting!" ) );
2228 }
2231 }
2232 break;
2233
2235 if( safe_mode == SAFE_MODE_STOP && !get_safemode().empty() ) {
2237 add_msg( m_info, _( "Creature whitelisted: %s" ), get_safemode().lastmon_whitelist );
2239 mostseen = 0;
2240 } else {
2241 get_safemode().show();
2242 }
2243 break;
2244
2245 case ACTION_SUICIDE:
2246 if( query_yn( _( "Commit suicide?" ) ) ) {
2247 if( query_yn( _( "REALLY commit suicide?" ) ) ) {
2248 u.apply_damage( &u, body_part_head, 99999 );
2249 u.moves = 0;
2250 u.place_corpse();
2252 }
2253 }
2254 break;
2255
2256 case ACTION_SAVE:
2257 if( query_yn( _( "Save and quit?" ) ) ) {
2258 if( save() ) {
2259 u.moves = 0;
2260 uquit = QUIT_SAVED;
2261 }
2262 }
2263 break;
2264
2265 case ACTION_QUICKSAVE:
2266 quicksave();
2267 return false;
2268
2269 case ACTION_QUICKLOAD:
2270 quickload();
2271 return false;
2272
2273 case ACTION_PL_INFO:
2275 break;
2276
2277 case ACTION_MAP:
2279 break;
2280
2281 case ACTION_SKY:
2282 if( m.is_outside( u.pos() ) ) {
2284 } else {
2285 add_msg( m_info, _( "You can't see the sky from here." ) );
2286 }
2287 break;
2288
2289 case ACTION_MISSIONS:
2290 list_missions();
2291 break;
2292
2293 case ACTION_SCORES:
2295 break;
2296
2297 case ACTION_FACTIONS:
2298 faction_manager_ptr->display();
2299 break;
2300
2301 case ACTION_MORALE:
2302 u.disp_morale();
2303 break;
2304
2305 case ACTION_MESSAGES:
2307 break;
2308
2309 case ACTION_HELP:
2311 break;
2312
2313 case ACTION_OPTIONS:
2314 get_options().show( true );
2315 break;
2316
2317 case ACTION_AUTOPICKUP:
2319 break;
2320
2321 case ACTION_AUTONOTES:
2323 break;
2324
2325 case ACTION_SAFEMODE:
2326 get_safemode().show();
2327 break;
2328
2331 break;
2332
2333 case ACTION_COLOR:
2334 all_colors.show_gui();
2335 break;
2336
2337 case ACTION_WORLD_MODS:
2338 world_generator->show_active_world_mods( world_generator->active_world->active_mod_order );
2339 break;
2340
2341 case ACTION_DEBUG:
2343 break; //don't do anything when sharing and not debugger
2344 }
2346 break;
2347
2350 break;
2351
2354 break;
2355
2358 break;
2359
2362 break;
2363
2365 get_options().get_option( "AUTO_FEATURES" ).setNext();
2366 get_options().save();
2367 //~ Auto Features are now ON/OFF
2368 add_msg( _( "%s are now %s." ),
2369 get_options().get_option( "AUTO_FEATURES" ).getMenuText(),
2370 get_option<bool>( "AUTO_FEATURES" ) ? _( "ON" ) : _( "OFF" ) );
2371 break;
2372
2374 get_options().get_option( "AUTO_PULP_BUTCHER" ).setNext();
2375 get_options().save();
2376 //~ Auto Pulp/Pulp Adjacent/Butcher is now set to x
2377 add_msg( _( "%s is now set to %s." ),
2378 get_options().get_option( "AUTO_PULP_BUTCHER" ).getMenuText(),
2379 get_options().get_option( "AUTO_PULP_BUTCHER" ).getValueName() );
2380 break;
2381
2383 get_options().get_option( "AUTO_MINING" ).setNext();
2384 get_options().save();
2385 //~ Auto Mining is now ON/OFF
2386 add_msg( _( "%s is now %s." ),
2387 get_options().get_option( "AUTO_MINING" ).getMenuText(),
2388 get_option<bool>( "AUTO_MINING" ) ? _( "ON" ) : _( "OFF" ) );
2389 break;
2390
2392 if( g->u.get_value( "THIEF_MODE" ) == "THIEF_ASK" ) {
2393 u.set_value( "THIEF_MODE", "THIEF_HONEST" );
2394 u.set_value( "THIEF_MODE_KEEP", "YES" );
2395 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2396 add_msg( _( "You will not pick up other peoples belongings." ) );
2397 } else if( g->u.get_value( "THIEF_MODE" ) == "THIEF_HONEST" ) {
2398 u.set_value( "THIEF_MODE", "THIEF_STEAL" );
2399 u.set_value( "THIEF_MODE_KEEP", "YES" );
2400 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2401 add_msg( _( "You will pick up also those things that belong to others!" ) );
2402 } else if( g->u.get_value( "THIEF_MODE" ) == "THIEF_STEAL" ) {
2403 u.set_value( "THIEF_MODE", "THIEF_ASK" );
2404 u.set_value( "THIEF_MODE_KEEP", "NO" );
2405 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2406 add_msg( _( "You will be reminded not to steal." ) );
2407 } else {
2408 // ERROR
2409 add_msg( _( "THIEF_MODE CONTAINED BAD VALUE [ %s ]!" ), g->u.get_value( "THIEF_MODE" ) );
2410 }
2411 break;
2412
2414 get_options().get_option( "AUTO_FORAGING" ).setNext();
2415 get_options().save();
2416 //~ Auto Foraging is now set to x
2417 add_msg( _( "%s is now set to %s." ),
2418 get_options().get_option( "AUTO_FORAGING" ).getMenuText(),
2419 get_options().get_option( "AUTO_FORAGING" ).getValueName() );
2420 break;
2421
2423 get_options().get_option( "AUTO_PICKUP" ).setNext();
2424 get_options().save();
2425 //~ Auto pickup is now set to x
2426 add_msg( _( "%s is now set to %s." ),
2427 get_options().get_option( "AUTO_PICKUP" ).getMenuText(),
2428 get_options().get_option( "AUTO_PICKUP" ).getValueName() );
2429 break;
2430
2433 break; //don't do anything when sharing and not debugger
2434 }
2435 display_scent();
2436 break;
2437
2440 break; //don't do anything when sharing and not debugger
2441 }
2442 display_scent();
2443 break;
2444
2447 break; //don't do anything when sharing and not debugger
2448 }
2450 break;
2453 break; //don't do anything when sharing and not debugger
2454 }
2456 break;
2459 break; //don't do anything when sharing and not debugger
2460 }
2462 break;
2463
2466 break; //don't do anything when sharing and not debugger
2467 }
2469 break;
2470
2473 break; //don't do anything when sharing and not debugger
2474 }
2476 break;
2477
2480 break; //don't do anything when sharing and not debugger
2481 }
2483 break;
2484
2486 g->debug_submap_grid_overlay = !g->debug_submap_grid_overlay;
2487 break;
2488
2491 break;
2492
2495 break; //don't do anything when sharing and not debugger
2496 }
2498 if( debug_mode ) {
2499 add_msg( m_info, _( "Debug mode ON!" ) );
2500 } else {
2501 add_msg( m_info, _( "Debug mode OFF!" ) );
2502 }
2503 break;
2504
2505 case ACTION_ZOOM_IN:
2506 zoom_in();
2508 break;
2509
2510 case ACTION_ZOOM_OUT:
2511 zoom_out();
2513 break;
2514
2515 case ACTION_ITEMACTION:
2517 break;
2518
2519 case ACTION_AUTOATTACK:
2521 break;
2522
2523 default:
2524 break;
2525 }
2526 }
2527 if( act != ACTION_TIMEOUT ) {
2528 u.mod_moves( -current_turn.moves_elapsed() );
2529 }
2530 gamemode->post_action( act );
2531
2532 u.movecounter = ( !u.is_dead_state() ? ( before_action_moves - u.moves ) : 0 );
2533 dbg( DL::Info ) << string_format( "%s: [%d] %d - %d = %d", action_ident( act ),
2534 to_turn<int>( calendar::turn ), before_action_moves, u.movecounter, u.moves );
2535 return ( !u.is_dead_state() );
2536}
cata::optional< std::string > press_x_if_bound(action_id act)
Definition: action.cpp:472
bool can_action_change_worldstate(const action_id act)
Lookup whether an action can affect the state of the game world.
Definition: action.cpp:350
action_id look_up_action(const std::string &ident)
Lookup an action ID by its unique string identifier.
Definition: action.cpp:421
action_id handle_main_menu()
Show in-game main menu.
Definition: action.cpp:944
point get_delta_from_movement_action(const action_id act, const iso_rotate rot)
Definition: action.cpp:510
action_id handle_action_menu()
Show the action menu.
Definition: action.cpp:658
@ ACTION_SAFEMODE
Open safemode manager.
Definition: action.h:265
@ ACTION_PEEK
Peek through something (e.g.
Definition: action.h:121
@ ACTION_OPEN
Open an item (e.g.
Definition: action.h:99
@ ACTION_CRAFT
Open crafting menu.
Definition: action.h:199
@ ACTION_DROP
Open the drop-item menu.
Definition: action.h:181
@ ACTION_READ
Open the read menu.
Definition: action.h:153
@ ACTION_TOGGLE_AUTO_PICKUP
Turn auto pickup on/off.
Definition: action.h:311
@ ACTION_MOVE_BACK_LEFT
Move towards bottom-left of screen / decelerate and steer left.
Definition: action.h:51
@ ACTION_ZOOM_IN
Zoom view out.
Definition: action.h:289
@ ACTION_EAT
Open the default consume item menu.
Definition: action.h:149
@ ACTION_SMASH
Smash something.
Definition: action.h:103
@ ACTION_ADVANCEDINV
Open the advanced inventory screen.
Definition: action.h:135
@ ACTION_QUICKSAVE
Quicksave the game.
Definition: action.h:227
@ ACTION_HELP
Display help screen.
Definition: action.h:253
@ ACTION_MESSAGES
Display messages screen.
Definition: action.h:251
@ ACTION_ZONES
Open the zone manager.
Definition: action.h:125
@ ACTION_TOGGLE_PIXEL_MINIMAP
Turn pixel minimap on/off.
Definition: action.h:295
@ ACTION_USE
Open the use menu.
Definition: action.h:141
@ ACTION_QUICKLOAD
Quickload the game.
Definition: action.h:229
@ ACTION_LIST_ITEMS
List items and monsters in a given square.
Definition: action.h:123
@ ACTION_DEBUG
Open debug menu.
Definition: action.h:279
@ ACTION_OPTIONS
Display options window.
Definition: action.h:259
@ ACTION_MOVE_FORTH
Move towards top of screen / accelerate.
Definition: action.h:41
@ ACTION_PICK_STYLE
Open the martial-arts style menu.
Definition: action.h:157
@ ACTION_CONSTRUCT
Open construct menu.
Definition: action.h:205
@ ACTION_MOVE_FORTH_RIGHT
Move towards top-right of screen / accelerate and steer right.
Definition: action.h:43
@ ACTION_SORT_ARMOR
Open the armor sorting menu.
Definition: action.h:189
@ ACTION_OPEN_CONSUME
Open the custom consume item menu.
Definition: action.h:151
@ ACTION_MORALE
Display morale effects screen.
Definition: action.h:249
@ ACTION_NULL
Invalid action used for various lookup errors.
Definition: action.h:24
@ ACTION_RESET_MOVE
Reset movement mode to walk
Definition: action.h:63
@ ACTION_CHAT
Chat with something.
Definition: action.h:117
@ ACTION_RELOAD_WIELDED
Attempt to reload wielded object.
Definition: action.h:163
@ ACTION_MOVE_DOWN
Descend a staircase.
Definition: action.h:57
@ ACTION_MISSIONS
Display missions screen.
Definition: action.h:243
@ ACTION_AUTONOTES
Open autonotes manager.
Definition: action.h:263
@ ACTION_WIELD
Open the wield menu.
Definition: action.h:155
@ ACTION_THROW
Open the throw menu.
Definition: action.h:169
@ ACTION_TOGGLE_AUTO_MINING
Turn auto mining on/off.
Definition: action.h:307
@ ACTION_INVENTORY
Open the primary inventory screen.
Definition: action.h:133
@ ACTION_TOGGLE_AUTOSAFE
Turn automatic triggering of safemode on/off.
Definition: action.h:217
@ ACTION_OPEN_MOVEMENT
Open movement mode menu.
Definition: action.h:69
@ ACTION_COMPARE
Open the item compare screen.
Definition: action.h:137
@ ACTION_SCORES
Display scores screen.
Definition: action.h:245
@ ACTION_BUTCHER
Butcher or disassemble objects in current square.
Definition: action.h:115
@ ACTION_SEC_SELECT
Click on a point with secondary mouse button (usually right button)
Definition: action.h:31
@ ACTION_TOGGLE_CROUCH
Toggle crouch on/off.
Definition: action.h:67
@ ACTION_TOGGLE_HOUR_TIMER
Toggle timing of the game hours.
Definition: action.h:327
@ ACTION_SELECT
Click on a point with primary mouse button (usually left button)
Definition: action.h:29
@ ACTION_MAIN_MENU
Display main menu.
Definition: action.h:255
@ ACTION_DISPLAY_SUBMAP_GRID
Toggle submap grid overlay.
Definition: action.h:325
@ ACTION_WAIT
Open wait menu.
Definition: action.h:197
@ ACTION_ACTIONMENU
Open the action menu.
Definition: action.h:291
@ ACTION_DISASSEMBLE
Open disassemble menu.
Definition: action.h:207
@ ACTION_LOOT
Sort out the loot.
Definition: action.h:127
@ ACTION_TOGGLE_FULLSCREEN
Toggle full-screen mode.
Definition: action.h:277
@ ACTION_MAP
Display over-map.
Definition: action.h:239
@ ACTION_MEND
Open the mending menu (e.g.
Definition: action.h:167
@ ACTION_TOGGLE_THIEF_MODE
Toggle permanent attitude to stealing.
Definition: action.h:219
@ ACTION_USE_WIELDED
Use currently wielded item.
Definition: action.h:143
@ ACTION_PL_INFO
Display player status screen.
Definition: action.h:237
@ ACTION_DISPLAY_SCENT_TYPE
Toggle scent type map.
Definition: action.h:283
@ ACTION_TOGGLE_AUTO_FORAGING
Turn auto foraging on/off.
Definition: action.h:309
@ ACTION_FIRE_BURST
Burst-fire the current weapon.
Definition: action.h:173
@ ACTION_BIONICS
Open the bionics menu.
Definition: action.h:185
@ ACTION_CONTROL_VEHICLE
Open vehicle control menu.
Definition: action.h:211
@ ACTION_SAVE
Save the game and quit.
Definition: action.h:225
@ ACTION_MOVE_UP
Ascend a staircase.
Definition: action.h:59
@ ACTION_TOGGLE_PANEL_ADM
Turn admin panel on/off.
Definition: action.h:297
@ ACTION_TOGGLE_AUTO_PULP_BUTCHER
Change auto pulp/butcher mode.
Definition: action.h:305
@ ACTION_TOGGLE_AUTO_TRAVEL_MODE
Turn auto travel mode on/off.
Definition: action.h:213
@ ACTION_COLOR
Open color manager.
Definition: action.h:267
@ ACTION_TIMEOUT
Input timeout.
Definition: action.h:39
@ ACTION_TOGGLE_RUN
Toggle run on/off.
Definition: action.h:65
@ ACTION_FACTIONS
Display factions screen.
Definition: action.h:247
@ ACTION_GRAB
Grab or let go of an object.
Definition: action.h:111
@ ACTION_MOVE_BACK
Move towards bottom of screen / decelerate.
Definition: action.h:49
@ ACTION_CAST_SPELL
Cast a spell (only if any spells are known)
Definition: action.h:179
@ ACTION_DIR_DROP
Drop items in a given direction.
Definition: action.h:183
@ ACTION_AUTOATTACK
Auto select and attack hostile creature within range.
Definition: action.h:191
@ ACTION_CYCLE_MOVE
Cycle run/walk/crouch mode.
Definition: action.h:61
@ ACTION_SKY
Show sky state for trying to predict weather.
Definition: action.h:241
@ ACTION_FIRE
Fire the wielded weapon, or open fire menu if none.
Definition: action.h:171
@ ACTION_PAUSE
Pause an on-going activity.
Definition: action.h:37
@ ACTION_MOVE_BACK_RIGHT
Move towards bottom-right of screen / decelerate and steer right.
Definition: action.h:47
@ ACTION_MUTATIONS
Open the mutations menu.
Definition: action.h:187
@ ACTION_HAUL
Haul pile of items, or let go of them.
Definition: action.h:113
@ ACTION_MOVE_RIGHT
Move / steer right.
Definition: action.h:45
@ ACTION_SLEEP
Open sleep menu.
Definition: action.h:209
@ ACTION_ITEMACTION
Open the item uses menu.
Definition: action.h:293
@ ACTION_MOVE_LEFT
Move / steer left.
Definition: action.h:53
@ ACTION_SELECT_DEFAULT_AMMO
Change default ammo for current weapon.
Definition: action.h:177
@ ACTION_AUTOPICKUP
Open autopickup manager.
Definition: action.h:261
@ ACTION_SUICIDE
Commit suicide.
Definition: action.h:231
@ NUM_ACTIONS
Not an action, serves as count of enumerated actions.
Definition: action.h:329
@ ACTION_ZOOM_OUT
Zoom view in.
Definition: action.h:287
@ ACTION_SELECT_FIRE_MODE
Change fire mode of the current weapon.
Definition: action.h:175
@ ACTION_UNLOAD
Open the unload item (e.g.
Definition: action.h:165
@ ACTION_RECRAFT
Repeat last craft command.
Definition: action.h:201
@ ACTION_TAKE_OFF
Open the take-off clothing selection menu.
Definition: action.h:147
@ ACTION_PICKUP_FEET
Pick up items from current square.
Definition: action.h:109
@ ACTION_TOGGLE_AUTO_FEATURES
Turn auto features on/off.
Definition: action.h:303
@ ACTION_WORLD_MODS
Open active world mods.
Definition: action.h:269
@ ACTION_TOGGLE_DEBUG_MODE
Toggle debug mode.
Definition: action.h:285
@ ACTION_ORGANIZE
Swap inventory letters.
Definition: action.h:139
@ ACTION_MOVE_FORTH_LEFT
Move towards top-left of screen / accelerate and steer left.
Definition: action.h:55
@ ACTION_RELOAD_TILESET
Reload current tileset.
Definition: action.h:301
@ ACTION_CLOSE
Close an item (e.g.
Definition: action.h:101
@ ACTION_RELOAD_WEAPON
Attempt to reload wielded weapon, then fall back to the load item select menu.
Definition: action.h:161
@ ACTION_RELOAD_ITEM
Open the load item (e.g.
Definition: action.h:159
@ ACTION_PICKUP
Pick up items from current/adjacent squares.
Definition: action.h:107
@ ACTION_LONGCRAFT
Open batch crafting menu.
Definition: action.h:203
@ ACTION_DISTRACTION_MANAGER
Open distraction manager.
Definition: action.h:271
@ ACTION_WEAR
Open the wear clothing selection menu.
Definition: action.h:145
void create_advanced_inv()
auto_notes::auto_note_settings & get_auto_notes_settings()
Definition: auto_note.cpp:386
auto_pickup::player_settings & get_auto_pickup()
Definition: auto_pickup.cpp:38
const bodypart_str_id body_part_head("head")
bool tile_iso
Using isometric tileset.
bool debug_mode
Extended debugging mode, can be toggled during game.
bool has_active_mutation(const trait_id &b) const
Definition: mutation.cpp:367
pimpl< character_martial_arts > martial_arts_data
Definition: character.h:1525
bool has_active_item(const itype_id &id) const
Whether the player carries an active item of the given item type.
Definition: character.cpp:2561
void place_corpse()
std::set< tripoint > get_path_avoid() const override
Returns a set of points we do not want to path through.
Definition: character.cpp:9951
bool has_destination_activity() const
bool is_auto_moving() const
void start_destination_activity()
action_id get_next_auto_move_direction()
const pathfinding_settings & get_pathfinding_settings() const override
Returns settings for pathfinding.
Definition: character.cpp:9965
bool is_armed() const
Returns true if the character is wielding something.
Definition: melee.cpp:145
void dismount()
Definition: character.cpp:1247
item weapon
Definition: character.h:1521
void set_value(const std::string &key, const std::string &value)
Definition: creature.cpp:1331
std::string get_value(const std::string &key) const
Definition: creature.cpp:1341
void mod_moves(int nmoves)
Definition: creature.cpp:1408
void cycle_move_mode()
Definition: avatar.cpp:1170
void toggle_map_memory()
Definition: avatar.cpp:119
void toggle_crouch_mode()
Definition: avatar.cpp:1154
void toggle_run_mode()
Definition: avatar.cpp:1145
void disp_morale()
Provides the window and detailed morale data.
Definition: avatar.cpp:985
void reset_move_mode()
Definition: avatar.cpp:1163
void item_action_menu()
void display_radiation()
Definition: game.cpp:11351
void list_missions()
Definition: mission_ui.cpp:22
input_context get_player_input(std::string &action)
bool try_get_left_click_action(action_id &act, const tripoint &mouse_target)
Definition: game.cpp:2400
void set_safe_mode(safe_mode_type mode)
Definition: game.cpp:8729
void pickup_feet()
Definition: game.cpp:5740
void zones_manager()
Definition: game.cpp:6208
int turnssincelastmon
Definition: game.h:1047
void display_visibility()
Definition: game.cpp:11265
void display_scent()
Definition: game.cpp:11230
bool save()
Returns false if saving failed.
Definition: game.cpp:2893
void butcher()
Definition: game.cpp:8411
void display_temperature()
Definition: game.cpp:11251
bool auto_travel_mode
Definition: game.h:1044
void zoom_out()
Definition: game.cpp:7158
void toggle_pixel_minimap()
Definition: game.cpp:515
void toggle_debug_hour_timer()
Definition: game.cpp:11297
void display_transparency()
Definition: game.cpp:11358
void list_items_monsters()
Definition: game.cpp:7335
cata::optional< tripoint > look_around(bool force_3d=false)
Definition: game.cpp:6683
void chat()
Definition: npctalk.cpp:394
void quickload()
Definition: game.cpp:11393
void pickup()
Definition: game.cpp:5718
void vertical_move(int z, bool force, bool peeking=false)
Moves the player vertically.
Definition: game.cpp:10078
void open_consume_item_menu()
void display_lighting()
Definition: game.cpp:11325
void control_vehicle()
Definition: game.cpp:5288
void peek()
Definition: game.cpp:5747
void drop()
Definition: game.cpp:8149
bool try_get_right_click_action(action_id &act, const tripoint &mouse_target)
Definition: game.cpp:2428
bool check_safe_mode_allowed(bool repeat_safe_mode_warnings=true)
Check whether movement is allowed according to safe mode settings.
Definition: game.cpp:8667
void zoom_in()
Definition: game.cpp:7170
void toggle_fullscreen()
Definition: game.cpp:505
void display_vehicle_ai()
Definition: game.cpp:11258
void reload_tileset()
Definition: game.cpp:526
void mark_main_ui_adaptor_resize() const
Definition: game.cpp:3141
void drop_in_direction()
Definition: game.cpp:8154
void display_help()
Definition: help.cpp:140
cata::optional< tripoint > get_coordinates(const catacurses::window &capture_win_)
Get the coordinates associated with the last mouse click (if any).
Definition: input.cpp:1338
input_event get_raw_input()
Temporary method to retrieve the raw input received, so that input_contexts can be used in screens wh...
Definition: input.cpp:1299
action_id display_menu(bool permit_execute_action=false)
Displays the possible actions in the current context and their keybindings.
Definition: input.cpp:999
std::string get_keyname(int ch, input_event_t inp_type, bool portable=false) const
Get the key name associated with the given keyboard keycode.
Definition: input.cpp:415
bool is_gun() const
Can this item be used to perform a ranged attack?
Definition: item.cpp:6388
void gun_cycle_mode()
Switch to the next available firing mode.
Definition: item.cpp:7779
std::string display_name(unsigned int quantity=1) const
Returns the item name and the charges or contained charges (if the item can have charges at all).
Definition: item.cpp:4727
bool is_gunmod() const
Definition: item.cpp:6418
std::map< gun_mode_id, gun_mode > gun_all_modes() const
Get all possible modes for this gun inclusive of any attached gunmods.
Definition: item.cpp:7698
bool gun_set_mode(const gun_mode_id &mode)
Try to set the mode for a gun, returning false if no such mode is possible.
Definition: item.cpp:7770
bool is_outside(const tripoint &p) const
Definition: map.cpp:2563
std::vector< tripoint > route(const tripoint &f, const tripoint &t, const pathfinding_settings &settings, const std::set< tripoint > &pre_closed={{ }}) const
Calculate the best path using A*.
const tripoint & pos() const override
Definition: monster.cpp:256
short ignoring
Definition: monster.h:508
cOpt & get_option(const std::string &name)
Definition: options.cpp:3372
std::string show(bool ingame=false, bool world_options_only=false, const std::function< bool()> &on_quit=nullptr)
Definition: options.cpp:2754
void show_adm()
Definition: panels.cpp:2282
void pause()
Definition: player.cpp:609
void craft(const tripoint &loc=tripoint_zero)
Start various types of crafts.
Definition: crafting.cpp:340
void sort_armor()
Draws the UI and handles player input for the armor re-ordering window.
void power_mutations()
Definition: mutation_ui.cpp:89
void use_wielded()
Uses the current wielded weapon.
Definition: player.cpp:3058
int movecounter
Definition: player.h:603
void power_bionics()
Generates and handles the UI for player interaction with installed bionics.
Definition: bionics_ui.cpp:528
void recraft(const tripoint &loc=tripoint_zero)
Definition: crafting.cpp:351
void long_craft(const tripoint &loc=tripoint_zero)
Definition: crafting.cpp:360
void add_rule(const std::string &rule_in, Creature::Attitude attitude_in, int proximity_in, rule_state state_in)
void show()
Definition: safemode_ui.cpp:39
int moves_elapsed()
#define all_colors
Definition: color.h:15
cata::optional< construction_id > construction_menu(const bool blueprint)
@ Info
Information (default: enabled).
@ RULE_WHITELISTED
Definition: enums.h:53
@ SAFE_MODE_OFF
Definition: game.h:77
@ QUIT_SAVED
Definition: game.h:70
static void open_movement_mode_menu()
static void smash()
static void open()
#define dbg(x)
static void takeoff()
static void read()
static void wait()
static const efftype_id effect_laserlocked("laserlocked")
static void rcdrive(const point &d)
static void wear()
static void close()
static const bionic_id bio_remote("bio_remote")
static void pldrive(const tripoint &p)
static void haul()
static const trait_id trait_SHELL2("SHELL2")
static const trait_id trait_PROF_CHURL("PROF_CHURL")
static void cast_spell()
static void loot()
static void fire()
static void grab()
static void sleep()
static const itype_id itype_radiocontrol("radiocontrol")
help & get_help()
Definition: help.cpp:30
bool isDebugger()
Definition: mapsharing.cpp:65
bool isCompetitive()
Definition: mapsharing.cpp:35
void reload_wielded(bool prompt=false)
Reload wielded item.
void reload_item()
Prompt to reload some item.
void use_item(avatar &you, item_location &loc)
bool eat_here(avatar &you)
void wield()
Prompt to wield some item.
void autoattack(avatar &you, map &m)
void eat(avatar &you)
Eat food or fuel 'E' (or 'a')
void fire_wielded_weapon(avatar &you)
Checks if the wielded weapon is a gun and can be fired then starts interactive aiming.
void plthrow(avatar &you, item_location loc, const cata::optional< tripoint > &blind_throw_from_pos=cata::nullopt)
void reload_weapon(bool try_everything=true)
Reload a wielded gun/tool.
void mend(avatar &you, item_location loc)
void unload(avatar &you)
Prompts to unload some item.
void disp_info(Character &ch)
Handles and displays detailed character info for the '@' screen.
void debug()
void close_door(map &m, Character &who, const tripoint &closep)
Handles deducting moves, printing messages (only non-NPCs cause messages), actually closing it,...
Definition: gates.cpp:256
void compare(player &p, const cata::optional< tripoint > &offset)
void common(avatar &you)
void swap_letters(player &p)
void prompt_select_default_ammo_for(avatar &u, const item &w)
Prompts to select default ammo compatible with provided gun.
Definition: ranged.cpp:3754
void display_visible_weather()
Display overmap like with display() and display the weather that is within line of sight.
void display()
Display overmap centered at the player's position.
options_manager & get_options()
Definition: options.cpp:142
T get_option(const std::string &name)
Definition: options.h:368
static constexpr point point_south_west
Definition: point.h:281
static constexpr point point_north_east
Definition: point.h:277
static constexpr point point_north_west
Definition: point.h:283
An instance of an input, like a keypress etc.
Definition: input.h:95
std::vector< int > sequence
Definition: input.h:101
int get_first_input() const
Definition: input.cpp:100
input_event_t type
Definition: input.h:96
void handbrake()

References _, Creature::A_ANY, achievements_tracker_ptr, act, action, ACTION_ACTIONMENU, ACTION_ADVANCEDINV, ACTION_AUTOATTACK, ACTION_AUTONOTES, ACTION_AUTOPICKUP, ACTION_BIONICS, ACTION_BUTCHER, ACTION_CAST_SPELL, ACTION_CENTER, ACTION_CHAT, ACTION_CLOSE, ACTION_COLOR, ACTION_COMPARE, ACTION_CONSTRUCT, ACTION_CONTROL_VEHICLE, ACTION_CRAFT, ACTION_CYCLE_MOVE, ACTION_DEBUG, ACTION_DIR_DROP, ACTION_DISASSEMBLE, ACTION_DISPLAY_LIGHTING, ACTION_DISPLAY_RADIATION, ACTION_DISPLAY_SCENT, ACTION_DISPLAY_SCENT_TYPE, ACTION_DISPLAY_SUBMAP_GRID, ACTION_DISPLAY_TEMPERATURE, ACTION_DISPLAY_TRANSPARENCY, ACTION_DISPLAY_VEHICLE_AI, ACTION_DISPLAY_VISIBILITY, ACTION_DISTRACTION_MANAGER, ACTION_DROP, ACTION_EAT, ACTION_EXAMINE, ACTION_FACTIONS, ACTION_FIRE, ACTION_FIRE_BURST, ACTION_GRAB, ACTION_HAUL, ACTION_HELP, action_ident(), ACTION_IGNORE_ENEMY, ACTION_INVENTORY, ACTION_ITEMACTION, ACTION_KEYBINDINGS, ACTION_LIST_ITEMS, ACTION_LONGCRAFT, ACTION_LOOK, ACTION_LOOT, ACTION_MAIN_MENU, ACTION_MAP, ACTION_MEND, ACTION_MESSAGES, ACTION_MISSIONS, ACTION_MORALE, ACTION_MOVE_BACK, ACTION_MOVE_BACK_LEFT, ACTION_MOVE_BACK_RIGHT, ACTION_MOVE_DOWN, ACTION_MOVE_FORTH, ACTION_MOVE_FORTH_LEFT, ACTION_MOVE_FORTH_RIGHT, ACTION_MOVE_LEFT, ACTION_MOVE_RIGHT, ACTION_MOVE_UP, ACTION_MUTATIONS, ACTION_NULL, ACTION_OPEN, ACTION_OPEN_CONSUME, ACTION_OPEN_MOVEMENT, ACTION_OPTIONS, ACTION_ORGANIZE, ACTION_PAUSE, ACTION_PEEK, ACTION_PICK_STYLE, ACTION_PICKUP, ACTION_PICKUP_FEET, ACTION_PL_INFO, ACTION_QUICKLOAD, ACTION_QUICKSAVE, ACTION_READ, ACTION_RECRAFT, ACTION_RELOAD_ITEM, ACTION_RELOAD_TILESET, ACTION_RELOAD_WEAPON, ACTION_RELOAD_WIELDED, ACTION_RESET_MOVE, ACTION_SAFEMODE, ACTION_SAVE, ACTION_SCORES, ACTION_SEC_SELECT, ACTION_SELECT, ACTION_SELECT_DEFAULT_AMMO, ACTION_SELECT_FIRE_MODE, ACTION_SHIFT_E, ACTION_SHIFT_N, ACTION_SHIFT_NE, ACTION_SHIFT_NW, ACTION_SHIFT_S, ACTION_SHIFT_SE, ACTION_SHIFT_SW, ACTION_SHIFT_W, ACTION_SKY, ACTION_SLEEP, ACTION_SMASH, ACTION_SORT_ARMOR, ACTION_SUICIDE, ACTION_TAKE_OFF, ACTION_THROW, ACTION_TIMEOUT, ACTION_TOGGLE_AUTO_FEATURES, ACTION_TOGGLE_AUTO_FORAGING, ACTION_TOGGLE_AUTO_MINING, ACTION_TOGGLE_AUTO_PICKUP, ACTION_TOGGLE_AUTO_PULP_BUTCHER, ACTION_TOGGLE_AUTO_TRAVEL_MODE, ACTION_TOGGLE_AUTOSAFE, ACTION_TOGGLE_CROUCH, ACTION_TOGGLE_DEBUG_MODE, ACTION_TOGGLE_FULLSCREEN, ACTION_TOGGLE_HOUR_TIMER, ACTION_TOGGLE_MAP_MEMORY, ACTION_TOGGLE_PANEL_ADM, ACTION_TOGGLE_PIXEL_MINIMAP, ACTION_TOGGLE_RUN, ACTION_TOGGLE_SAFEMODE, ACTION_TOGGLE_THIEF_MODE, ACTION_UNLOAD, ACTION_USE, ACTION_USE_WIELDED, ACTION_WAIT, ACTION_WEAR, ACTION_WHITELIST_ENEMY, ACTION_WIELD, ACTION_WORLD_MODS, ACTION_ZONES, ACTION_ZOOM_IN, ACTION_ZOOM_OUT, add_msg(), safemode::add_rule(), all_colors, Character::apply_damage(), auto_travel_mode, avatar_action::autoattack(), bio_remote, body_part_head, butcher(), can_action_change_worldstate(), cast_spell(), chat(), check_safe_mode_allowed(), Character::clear_destination(), close(), doors::close_door(), game_menus::inv::common(), game_menus::inv::compare(), construction_menu(), control_vehicle(), Character::controlling_vehicle, player::craft(), create_advanced_inv(), avatar::cycle_move_mode(), dbg, debug_menu::debug(), debug_mode, destination_preview, crafting::disassemble(), Character::dismount(), character_display::disp_info(), avatar::disp_morale(), ui::omap::display(), help::display_help(), display_lighting(), input_context::display_menu(), Messages::display_messages(), item::display_name(), display_radiation(), display_scent(), display_temperature(), display_transparency(), display_vehicle_ai(), display_visibility(), ui::omap::display_visible_weather(), driving_view_offset, drop(), drop_in_direction(), avatar_action::eat(), avatar_action::eat_here(), effect_laserlocked, examine(), faction_manager_ptr, fire(), avatar_action::fire_wielded_weapon(), g, gamemode, get_auto_notes_settings(), get_auto_pickup(), input_context::get_coordinates(), get_delta_from_movement_action(), get_distraction_manager(), input_event::get_first_input(), get_help(), input_manager::get_keyname(), get_kill_tracker(), panel_manager::get_manager(), avatar::get_mon_visible(), Character::get_next_auto_move_direction(), options_manager::get_option(), get_option(), get_options(), Character::get_path_avoid(), Character::get_pathfinding_settings(), get_player_input(), input_context::get_raw_input(), get_safemode(), Creature::get_value(), grab(), item::gun_all_modes(), item::gun_cycle_mode(), item::gun_set_mode(), handbrake(), handle_action_menu(), handle_main_menu(), Character::has_active_bionic(), Character::has_active_item(), Character::has_active_mutation(), Character::has_destination(), Character::has_destination_activity(), Creature::has_effect(), Character::has_trait(), haul(), monster::ignoring, Character::in_vehicle, Info, inp_mngr, Character::is_armed(), Character::is_auto_moving(), player::is_dead_state(), item::is_gun(), item::is_gunmod(), Character::is_mounted(), map::is_outside(), MAP_SHARING::isCompetitive(), MAP_SHARING::isDebugger(), item_action_menu(), itype_radiocontrol, list_items_monsters(), list_missions(), player::long_craft(), look_around(), look_up_action(), loot(), m, m_bad, m_info, m_warning, mark_main_ui_adaptor_resize(), Character::martial_arts_data, avatar_action::mend(), MF_RIDEABLE_MECH, Creature::mod_moves(), mostseen, Character::mounted_creature, avatar_action::move(), player::movecounter, Creature::moves, user_turn::moves_elapsed(), om_direction::name(), monster_visible_info::new_seen_mon, no, cata::nullopt, NUM_ACTIONS, open(), open_consume_item_menu(), open_movement_mode_menu(), player::pause(), peek(), pickup(), pickup_feet(), Character::place_corpse(), pldrive(), avatar_action::plthrow(), point_east, point_north, point_north_east, point_north_west, point_south, point_south_east, point_south_west, point_west, point_zero, Character::pos(), monster::pos(), Character::posx(), Character::posy(), Character::posz(), player::power_bionics(), player::power_mutations(), press_x(), press_x_if_bound(), ranged::prompt_select_default_ammo_for(), query_yn(), quickload(), quicksave(), QUIT_DIED, QUIT_SAVED, QUIT_SUICIDE, QUIT_WATCH, rcdrive(), read(), player::recraft(), avatar_action::reload_item(), reload_tileset(), avatar_action::reload_weapon(), avatar_action::reload_wielded(), remoteveh(), Creature::remove_effect(), avatar::reset_move_mode(), rl_dist(), map::route(), RULE_WHITELISTED, safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAFE_MODE_STOP, safe_mode_warning_logged, save(), options_manager::save(), Character::sees(), SEEX, input_event::sequence, Character::set_destination(), set_safe_mode(), Creature::set_value(), options_manager::cOpt::setNext(), auto_pickup::player_settings::show(), distraction_manager::distraction_manager_gui::show(), safemode::show(), options_manager::show(), panel_manager::show_adm(), auto_notes::auto_note_settings::show_gui(), show_scores_ui(), sleep(), smash(), player::sort_armor(), Character::start_destination_activity(), stats(), string_format(), game_menus::inv::swap_letters(), takeoff(), tile_iso, avatar::toggle_crouch_mode(), toggle_debug_hour_timer(), toggle_fullscreen(), avatar::toggle_map_memory(), toggle_pixel_minimap(), avatar::toggle_run_mode(), trait_PROF_CHURL, trait_SHELL2, tripoint_above, tripoint_below, try_get_left_click_action(), try_get_right_click_action(), calendar::turn, turnssincelastmon, input_event::type, u, avatar_action::unload(), uquit, avatar_action::use_item(), use_tiles, player::use_wielded(), user_action_counter, map::veh_at(), vertical_move(), player::view_offset, w_terrain, wait(), Character::weapon, wear(), avatar_action::wield(), world_generator, point::x, tripoint::x, point::y, tripoint::y, yes, zones_manager(), zoom_in(), and zoom_out().

Referenced by do_turn().

◆ handle_key_blocking_activity()

void game::handle_key_blocking_activity ( )
private

Definition at line 2080 of file game.cpp.

2081{
2083 const std::string action = ctxt.handle_input( 0 );
2084 bool refresh = true;
2085 if( action == "pause" ) {
2087 cancel_activity_query( _( "Confirm:" ) );
2088 }
2089 } else if( action == "player_data" ) {
2091 } else if( action == "messages" ) {
2093 } else if( action == "help" ) {
2095 } else if( action != "HELP_KEYBINDINGS" ) {
2096 refresh = false;
2097 }
2098 if( refresh ) {
2101 }
2102}
bool cancel_activity_query(const std::string &text)
Asks if the player wants to cancel their activity, and if so cancels it.
Definition: game.cpp:1864
const std::string & handle_input()
Handles input and returns the next action in the queue.
Definition: input.cpp:854
bool interruptable_with_kb
Controls whether this activity can be cancelled with 'pause' action.
void refresh()

References _, action, Character::activity, cancel_activity_query(), character_display::disp_info(), help::display_help(), Messages::display_messages(), get_default_mode_input_context(), get_help(), input_context::handle_input(), player_activity::interruptable_with_kb, ui_manager::redraw(), catacurses::refresh(), refresh_display(), and u.

Referenced by process_voluntary_act_interrupt().

◆ handle_mouseview()

bool game::handle_mouseview ( input_context ctxt,
std::string &  action 
)
private

Definition at line 2106 of file game.cpp.

2107{
2108 cata::optional<tripoint> liveview_pos;
2109
2110 do {
2111 action = ctxt.handle_input();
2112 if( action == "MOUSE_MOVE" ) {
2113 const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
2114 if( mouse_pos && ( !liveview_pos || *mouse_pos != *liveview_pos ) ) {
2115 liveview_pos = mouse_pos;
2116 liveview.show( *liveview_pos );
2117 } else if( !mouse_pos ) {
2118 liveview_pos.reset();
2119 liveview.hide();
2120 }
2122 }
2123 } while( action == "MOUSE_MOVE" ); // Freeze animation when moving the mouse
2124
2125 if( action != "TIMEOUT" ) {
2126 // Keyboard event, break out of animation loop
2127 liveview.hide();
2128 return false;
2129 }
2130
2131 // Mouse movement or un-handled key
2132 return true;
2133}
void reset() noexcept
Definition: optional.h:158
void hide()
Definition: live_view.cpp:33
void show(const tripoint &p)
Definition: live_view.cpp:38

References action, input_context::get_coordinates(), input_context::handle_input(), live_view::hide(), liveview, ui_manager::redraw(), cata::optional< T >::reset(), live_view::show(), and w_terrain.

Referenced by get_player_input().

◆ has_gametype()

bool game::has_gametype ( ) const

Definition at line 638 of file game.cpp.

639{
640 return gamemode && gamemode->id() != SGAME_NULL;
641}

References gamemode, and SGAME_NULL.

◆ init_autosave()

void game::init_autosave ( )
private

Definition at line 11365 of file game.cpp.

11366{
11368 last_save_timestamp = time( nullptr );
11369}

References last_save_timestamp, and moves_since_last_save.

Referenced by load(), and start_game().

◆ inv_map_splice()

item_location game::inv_map_splice ( item_filter  filter,
const std::string &  title,
int  radius = 0,
const std::string &  none_message = "" 
)

Custom-filtered menu for inventory and nearby items and those that within specified radius.

Definition at line 397 of file game_inventory.cpp.

399{
401 title, radius, none_message );
402}
static item_location_filter convert_filter(const item_filter &filter)
static item_location inv_internal(player &u, const inventory_selector_preset &preset, const std::string &title, int radius, const std::string &none_message, const std::string &hint=std::string())
std::string title(holiday current_holiday)
Definition: path_info.cpp:334

References convert_filter(), inv_internal(), PATH_INFO::title(), and u.

◆ invalidate_main_ui_adaptor()

void game::invalidate_main_ui_adaptor ( ) const

◆ is_core_data_loaded()

bool game::is_core_data_loaded ( ) const

Returns whether the core data is currently loaded.

Definition at line 438 of file game.cpp.

439{
441}
bool is_data_finalized() const
Returns whether the data is finalized and ready to be utilized.
Definition: init.h:167

References DynamicDataLoader::get_instance(), and DynamicDataLoader::is_data_finalized().

◆ is_dangerous_tile()

bool game::is_dangerous_tile ( const tripoint dest_loc) const

Definition at line 8797 of file game.cpp.

8798{
8799 return !( get_dangerous_tile( dest_loc ).empty() );
8800}
std::vector< std::string > get_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:8819

References get_dangerous_tile().

Referenced by walk_move().

◆ is_empty()

bool game::is_empty ( const tripoint p)

Returns true if there is no player, NPC, or monster on the tile and move_cost > 0.

Definition at line 4973 of file game.cpp.

4974{
4975 return ( m.passable( p ) || m.has_flag( "LIQUID", p ) ) &&
4976 critter_at( p ) == nullptr;
4977}

References critter_at(), map::has_flag(), m, and map::passable().

Referenced by grabbed_furn_move(), monmove(), place_player(), and update_stair_monsters().

◆ is_game_over()

bool game::is_game_over ( )
private

Definition at line 2473 of file game.cpp.

2474{
2475 if( uquit == QUIT_WATCH ) {
2476 // deny player movement and dodging
2477 u.moves = 0;
2478 // prevent pain from updating
2479 u.set_pain( 0 );
2480 // prevent dodging
2481 u.dodges_left = 0;
2482 return false;
2483 }
2484 if( uquit == QUIT_DIED ) {
2485 if( u.in_vehicle ) {
2486 m.unboard_vehicle( u.pos() );
2487 }
2488 u.place_corpse();
2489 return true;
2490 }
2491 if( uquit == QUIT_SUICIDE ) {
2492 if( u.in_vehicle ) {
2493 m.unboard_vehicle( u.pos() );
2494 }
2495 return true;
2496 }
2497 if( uquit != QUIT_NO ) {
2498 return true;
2499 }
2500 // is_dead_state() already checks hp_torso && hp_head, no need to for loop it
2501 if( u.is_dead_state() ) {
2503 if( get_option<std::string>( "DEATHCAM" ) == "always" ) {
2504 uquit = QUIT_WATCH;
2505 } else if( get_option<std::string>( "DEATHCAM" ) == "ask" ) {
2506 uquit = query_yn( _( "Watch the last moments of your life…?" ) ) ?
2508 } else if( get_option<std::string>( "DEATHCAM" ) == "never" ) {
2509 uquit = QUIT_DIED;
2510 } else {
2511 // Something funky happened here, just die.
2512 dbg( DL::Error ) << "no deathcam option given to options, defaulting to QUIT_DIED";
2513 uquit = QUIT_DIED;
2514 }
2515 return is_game_over();
2516 }
2517 return false;
2518}
int dodges_left
Definition: character.h:559
void set_pain(int npain) override
Sets new intensity of pain an reacts to it.
Definition: player.cpp:972
@ Error
Error (default: enabled).
#define dbg(x)
Definition: game.cpp:193
void deactivate()
Definition: messages.cpp:357

References _, dbg, Messages::deactivate(), Character::dodges_left, Error, Character::in_vehicle, player::is_dead_state(), is_game_over(), m, Creature::moves, Character::place_corpse(), Character::pos(), query_yn(), QUIT_DIED, QUIT_NO, QUIT_SUICIDE, QUIT_WATCH, player::set_pain(), u, map::unboard_vehicle(), and uquit.

Referenced by do_turn(), and is_game_over().

◆ is_hostile_nearby()

Creature * game::is_hostile_nearby ( )

Definition at line 3732 of file game.cpp.

3733{
3734 int distance = ( get_option<int>( "SAFEMODEPROXIMITY" ) <= 0 ) ? MAX_VIEW_DISTANCE :
3735 get_option<int>( "SAFEMODEPROXIMITY" );
3736 return is_hostile_within( distance );
3737}
Creature * is_hostile_within(int distance)
Definition: game.cpp:3744

References is_hostile_within(), and MAX_VIEW_DISTANCE.

◆ is_hostile_very_close()

Creature * game::is_hostile_very_close ( )

Definition at line 3739 of file game.cpp.

3740{
3742}
static constexpr int DANGEROUS_PROXIMITY
Definition: game.cpp:195

References DANGEROUS_PROXIMITY, and is_hostile_within().

Referenced by butcher(), and process_voluntary_act_interrupt().

◆ is_hostile_within()

Creature * game::is_hostile_within ( int  distance)
private

Definition at line 3744 of file game.cpp.

3745{
3746 for( auto &critter : u.get_visible_creatures( distance ) ) {
3747 if( u.attitude_to( *critter ) == Creature::A_HOSTILE ) {
3748 return critter;
3749 }
3750 }
3751
3752 return nullptr;
3753}
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
std::vector< Creature * > get_visible_creatures(int range) const
Returns all creatures that this player can see and that are in the given range.
@ A_HOSTILE
Definition: creature.h:169

References Creature::A_HOSTILE, Character::attitude_to(), Character::get_visible_creatures(), and u.

Referenced by is_hostile_nearby(), and is_hostile_very_close().

◆ is_in_sunlight()

bool game::is_in_sunlight ( const tripoint p)

Returns true if p is outdoors and it is sunny.

Definition at line 4979 of file game.cpp.

4980{
4981 return weather::is_in_sunlight( m, p, get_weather().weather_id );
4982}
bool is_in_sunlight(const map &m, const tripoint &p, const weather_type_id &weather)
Definition: weather.cpp:1162

References get_weather, weather::is_in_sunlight(), and m.

Referenced by process_artifact().

◆ is_in_viewport()

bool game::is_in_viewport ( const tripoint p,
int  margin = 0 
) const

Definition at line 3378 of file game.cpp.

3379{
3380 const tripoint diff( u.pos() + u.view_offset - p );
3381
3382 return ( std::abs( diff.x ) <= getmaxx( w_terrain ) / 2 - margin ) &&
3383 ( std::abs( diff.y ) <= getmaxy( w_terrain ) / 2 - margin );
3384}

References catacurses::getmaxx(), catacurses::getmaxy(), Character::pos(), u, player::view_offset, w_terrain, tripoint::x, and tripoint::y.

◆ is_sheltered()

bool game::is_sheltered ( const tripoint p)

Returns true if p is indoors, underground, or in a car.

Definition at line 4984 of file game.cpp.

4985{
4986 return weather::is_sheltered( m, p );
4987}
bool is_sheltered(const map &m, const tripoint &p)
Definition: weather.cpp:1153

References weather::is_sheltered(), and m.

◆ is_zones_manager_open()

bool game::is_zones_manager_open ( ) const

Definition at line 6138 of file game.cpp.

6139{
6140 return zones_manager_open;
6141}
bool zones_manager_open
Is Zone manager open or not - changes graphics of some zone tiles.
Definition: game.h:1079

References zones_manager_open.

◆ item_action_menu()

void game::item_action_menu ( )
private

Definition at line 231 of file item_action.cpp.

232{
233 const auto &gen = item_action_generator::generator();
234 const action_map &item_actions = gen.get_item_action_map();
235
236 // HACK: A bit of a hack for now. If more pseudos get implemented, this should be un-hacked
237 std::vector<item *> pseudos;
238 item toolset( "toolset", calendar::turn );
239 if( u.has_active_bionic( bio_tools ) ) {
240 pseudos.push_back( &toolset );
241 }
242 item bio_claws_item( static_cast<std::string>( bio_claws_weapon ), calendar::turn );
243 if( u.has_active_bionic( bio_claws ) ) {
244 pseudos.push_back( &bio_claws_item );
245 }
246
247 item_action_map iactions = gen.map_actions_to_items( u, pseudos );
248 if( iactions.empty() ) {
249 popup( _( "You don't have any items with registered uses" ) );
250 }
251
252 uilist kmenu;
253 kmenu.text = _( "Execute which action?" );
254 kmenu.input_category = "ITEM_ACTIONS";
255 input_context ctxt( "ITEM_ACTIONS" );
256 for( const auto &id : item_actions ) {
257 ctxt.register_action( id.first, id.second.name );
258 kmenu.additional_actions.emplace_back( id.first, id.second.name );
259 }
260 actmenu_cb callback( item_actions );
261 kmenu.callback = &callback;
262 int num = 0;
263
264 const auto assigned_action = [&iactions]( const item_action_id & action ) {
265 return iactions.find( action ) != iactions.end();
266 };
267
268 std::vector<std::tuple<item_action_id, std::string, std::string>> menu_items;
269 // Sorts menu items by action.
270 using Iter = decltype( menu_items )::iterator;
271 const auto sort_menu = []( Iter from, Iter to ) {
272 std::sort( from, to, []( const std::tuple<item_action_id, std::string, std::string> &lhs,
273 const std::tuple<item_action_id, std::string, std::string> &rhs ) {
274 return std::get<1>( lhs ).compare( std::get<1>( rhs ) ) < 0;
275 } );
276 };
277 // Add mapped actions to the menu vector.
278 std::transform( iactions.begin(), iactions.end(), std::back_inserter( menu_items ),
279 []( const std::pair<item_action_id, item *> &elem ) {
280 std::string ss = elem.second->display_name();
281 if( elem.second->ammo_required() ) {
282 ss += string_format( " (%d/%d)", elem.second->ammo_required(), elem.second->ammo_remaining() );
283 }
284
285 const auto method = elem.second->get_use( elem.first );
286 if( method ) {
287 return std::make_tuple( method->get_type(), method->get_name(), ss );
288 } else {
289 return std::make_tuple( errstring, std::string( "NO USE FUNCTION" ), ss );
290 }
291 } );
292 // Sort mapped actions.
293 sort_menu( menu_items.begin(), menu_items.end() );
294 // Add unmapped but binded actions to the menu vector.
295 for( const auto &elem : item_actions ) {
296 if( key_bound_to( ctxt, elem.first ) != '\0' && !assigned_action( elem.first ) ) {
297 menu_items.emplace_back( elem.first, gen.get_action_name( elem.first ), "-" );
298 }
299 }
300 // Sort unmapped actions.
301 auto iter = menu_items.begin();
302 std::advance( iter, iactions.size() );
303 sort_menu( iter, menu_items.end() );
304 // Determine max lengths, to print the menu nicely.
305 std::pair<int, int> max_len;
306 for( const auto &elem : menu_items ) {
307 max_len.first = std::max( max_len.first, utf8_width( std::get<1>( elem ), true ) );
308 max_len.second = std::max( max_len.second, utf8_width( std::get<2>( elem ), true ) );
309 }
310 // Fill the menu.
311 for( const auto &elem : menu_items ) {
312 std::string ss;
313 ss += std::get<1>( elem );
314 ss += std::string( max_len.first - utf8_width( std::get<1>( elem ), true ), ' ' );
315 ss += std::string( 4, ' ' );
316
317 ss += std::get<2>( elem );
318 ss += std::string( max_len.second - utf8_width( std::get<2>( elem ), true ), ' ' );
319
320 const char bind = key_bound_to( ctxt, std::get<0>( elem ) );
321 const bool enabled = assigned_action( std::get<0>( elem ) );
322
323 kmenu.addentry( num, enabled, bind, ss );
324 num++;
325 }
326
327 kmenu.query();
328 if( kmenu.ret < 0 || kmenu.ret >= static_cast<int>( iactions.size() ) ) {
329 return;
330 }
331
332 const item_action_id action = std::get<0>( menu_items[kmenu.ret] );
333 item *it = iactions[action];
334
335 u.invoke_item( it, action );
336
337 u.inv.restack( u );
338 u.inv.unsort();
339}
inventory inv
Definition: character.h:1519
bool invoke_item(item *, const tripoint &pt) override
Asks how to use the item (if it has more than one use_method) and uses it.
Definition: avatar.cpp:1239
void restack(player &p)
Definition: inventory.cpp:398
void unsort()
Definition: inventory.cpp:226
static item_action_generator & generator()
Definition: item_action.h:32
std::string input_category
Definition: ui.h:325
std::vector< std::pair< std::string, translation > > additional_actions
Definition: ui.h:326
static char key_bound_to(const input_context &ctxt, const item_action_id &act)
Definition: item_action.cpp:47
static const bionic_id bio_claws("bio_claws")
static const bionic_id bio_tools("bio_tools")
static const bionic_id bio_claws_weapon("bio_claws_weapon")
std::string item_action_id
Definition: item_action.h:16
std::map< item_action_id, item_action > action_map
Definition: item_action.h:18
std::map< item_action_id, item * > item_action_map
Definition: item_action.h:17

References _, action, uilist::additional_actions, bio_claws, bio_claws_weapon, bio_tools, uilist::callback, item_action_generator::generator(), Character::has_active_bionic(), uilist::input_category, num, popup(), input_context::register_action(), second, uilist::text, iexamine::transform(), calendar::turn, and u.

Referenced by handle_action().

◆ knockback() [1/2]

void game::knockback ( const tripoint s,
const tripoint t,
int  force,
int  stun,
int  dam_mult,
Creature source 
)

Definition at line 4396 of file game.cpp.

4398{
4399 std::vector<tripoint> traj;
4400 traj.clear();
4401 traj = line_to( s, t, 0, 0 );
4402 traj.insert( traj.begin(), s ); // how annoying, line_to() doesn't include the originating point!
4403 traj = continue_line( traj, force );
4404 traj.insert( traj.begin(), t ); // how annoying, continue_line() doesn't either!
4405
4406 knockback( traj, stun, dam_mult, source );
4407}
std::vector< coords::coord_point< Point, Origin, Scale > > line_to(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:548
std::vector< tripoint > continue_line(const std::vector< tripoint > &line, const int distance)
Definition: line.cpp:408

References continue_line(), knockback(), and line_to().

Referenced by forced_door_closing(), and knockback().

◆ knockback() [2/2]

void game::knockback ( std::vector< tripoint > &  traj,
int  stun,
int  dam_mult,
Creature source = nullptr 
)

Definition at line 4413 of file game.cpp.

4415{
4416 // TODO: make the force parameter actually do something.
4417 // the header file says higher force causes more damage.
4418 // perhaps that is what it should do?
4419
4420 // TODO: refactor this so it's not copy/pasted 3 times
4421 tripoint tp = traj.front();
4422 if( !critter_at( tp ) ) {
4423 debugmsg( _( "Nothing at (%d,%d,%d) to knockback!" ), tp.x, tp.y, tp.z );
4424 return;
4425 }
4426 std::size_t force_remaining = traj.size();
4427 if( monster *const targ = critter_at<monster>( tp, true ) ) {
4428 if( stun > 0 ) {
4429 targ->add_effect( effect_stunned, 1_turns * stun );
4430 add_msg( _( "%s was stunned!" ), targ->name() );
4431 }
4432 for( size_t i = 1; i < traj.size(); i++ ) {
4433 if( m.impassable( traj[i].xy() ) || m.obstructed_by_vehicle_rotation( tp, traj[i] ) ) {
4434 targ->setpos( traj[i - 1] );
4435 force_remaining = traj.size() - i;
4436 if( stun != 0 ) {
4437 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4438 add_msg( _( "%s was stunned!" ), targ->name() );
4439 add_msg( _( "%s slammed into an obstacle!" ), targ->name() );
4440 targ->apply_damage( source, bodypart_id( "torso" ), dam_mult * force_remaining );
4441 targ->check_dead_state();
4442 }
4443 m.bash( traj[i], 2 * dam_mult * force_remaining );
4444 break;
4445 } else if( critter_at( traj[i] ) ) {
4446 targ->setpos( traj[i - 1] );
4447 force_remaining = traj.size() - i;
4448 if( stun != 0 ) {
4449 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4450 add_msg( _( "%s was stunned!" ), targ->name() );
4451 }
4452 traj.erase( traj.begin(), traj.begin() + i );
4453 if( critter_at<monster>( traj.front() ) ) {
4454 add_msg( _( "%s collided with something else and sent it flying!" ),
4455 targ->name() );
4456 } else if( npc *const guy = critter_at<npc>( traj.front() ) ) {
4457 if( guy->male ) {
4458 add_msg( _( "%s collided with someone else and sent him flying!" ),
4459 targ->name() );
4460 } else {
4461 add_msg( _( "%s collided with someone else and sent her flying!" ),
4462 targ->name() );
4463 }
4464 } else if( u.pos() == traj.front() ) {
4465 add_msg( m_bad, _( "%s collided with you and sent you flying!" ), targ->name() );
4466 }
4467 knockback( traj, stun, dam_mult, source );
4468 break;
4469 }
4470 targ->setpos( traj[i] );
4471 if( m.has_flag( "LIQUID", targ->pos() ) && targ->can_drown() && !targ->is_dead() ) {
4472 targ->die( source );
4473 if( u.sees( *targ ) ) {
4474 add_msg( _( "The %s drowns!" ), targ->name() );
4475 }
4476 }
4477 if( !m.has_flag( "LIQUID", targ->pos() ) && targ->has_flag( MF_AQUATIC ) &&
4478 !targ->is_dead() ) {
4479 targ->die( source );
4480 if( u.sees( *targ ) ) {
4481 add_msg( _( "The %s flops around and dies!" ), targ->name() );
4482 }
4483 }
4484 tp = traj[i];
4485 }
4486 } else if( npc *const targ = critter_at<npc>( tp ) ) {
4487 if( stun > 0 ) {
4488 targ->add_effect( effect_stunned, 1_turns * stun );
4489 add_msg( _( "%s was stunned!" ), targ->name );
4490 }
4491 for( size_t i = 1; i < traj.size(); i++ ) {
4492 if( m.impassable( traj[i].xy() ) ||
4493 m.obstructed_by_vehicle_rotation( tp, traj[i] ) ) { // oops, we hit a wall!
4494 targ->setpos( traj[i - 1] );
4495 force_remaining = traj.size() - i;
4496 if( stun != 0 ) {
4497 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4498 if( targ->has_effect( effect_stunned ) ) {
4499 add_msg( _( "%s was stunned!" ), targ->name );
4500 }
4501
4502 std::array<bodypart_id, 8> bps = {{
4503 bodypart_id( "head" ),
4504 bodypart_id( "arm_l" ), bodypart_id( "arm_r" ),
4505 bodypart_id( "hand_l" ), bodypart_id( "hand_r" ),
4506 bodypart_id( "torso" ),
4507 bodypart_id( "leg_l" ), bodypart_id( "leg_r" )
4508 }
4509 };
4510 for( const bodypart_id &bp : bps ) {
4511 if( one_in( 2 ) ) {
4512 targ->deal_damage( source, bp, damage_instance( DT_BASH, force_remaining * dam_mult ) );
4513 }
4514 }
4515 targ->check_dead_state();
4516 }
4517 m.bash( traj[i], 2 * dam_mult * force_remaining );
4518 break;
4519 } else if( critter_at( traj[i] ) ) {
4520 targ->setpos( traj[i - 1] );
4521 force_remaining = traj.size() - i;
4522 if( stun != 0 ) {
4523 add_msg( _( "%s was stunned!" ), targ->name );
4524 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4525 }
4526 traj.erase( traj.begin(), traj.begin() + i );
4527 const tripoint &traj_front = traj.front();
4528 if( critter_at<monster>( traj_front ) ) {
4529 add_msg( _( "%s collided with something else and sent it flying!" ),
4530 targ->name );
4531 } else if( npc *const guy = critter_at<npc>( traj_front ) ) {
4532 if( guy->male ) {
4533 add_msg( _( "%s collided with someone else and sent him flying!" ),
4534 targ->name );
4535 } else {
4536 add_msg( _( "%s collided with someone else and sent her flying!" ),
4537 targ->name );
4538 }
4539 } else if( u.posx() == traj_front.x && u.posy() == traj_front.y &&
4541 ( u.footwear_factor() == .5 && one_in( 2 ) ) ) ) ) {
4542 add_msg( _( "%s collided with you, and barely dislodges your tentacles!" ), targ->name );
4543 } else if( u.posx() == traj_front.x && u.posy() == traj_front.y ) {
4544 add_msg( m_bad, _( "%s collided with you and sent you flying!" ), targ->name );
4545 }
4546 knockback( traj, stun, dam_mult, source );
4547 break;
4548 }
4549 targ->setpos( traj[i] );
4550 tp = traj[i];
4551 }
4552 } else if( u.pos() == tp ) {
4553 if( stun > 0 ) {
4554 u.add_effect( effect_stunned, 1_turns * stun );
4555 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4556 "You were stunned for %d turns!",
4557 stun ),
4558 stun );
4559 }
4560 for( size_t i = 1; i < traj.size(); i++ ) {
4561 if( m.impassable( traj[i] ) ||
4562 m.obstructed_by_vehicle_rotation( tp, traj[i] ) ) { // oops, we hit a wall!
4563 u.setpos( traj[i - 1] );
4564 force_remaining = traj.size() - i;
4565 if( stun != 0 ) {
4566 if( u.has_effect( effect_stunned ) ) {
4567 add_msg( m_bad, vgettext( "You were stunned AGAIN for %d turn!",
4568 "You were stunned AGAIN for %d turns!",
4569 force_remaining ),
4570 force_remaining );
4571 } else {
4572 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4573 "You were stunned for %d turns!",
4574 force_remaining ),
4575 force_remaining );
4576 }
4577 u.add_effect( effect_stunned, 1_turns * force_remaining );
4578 std::array<bodypart_id, 8> bps = {{
4579 bodypart_id( "head" ),
4580 bodypart_id( "arm_l" ), bodypart_id( "arm_r" ),
4581 bodypart_id( "hand_l" ), bodypart_id( "hand_r" ),
4582 bodypart_id( "torso" ),
4583 bodypart_id( "leg_l" ), bodypart_id( "leg_r" )
4584 }
4585 };
4586 for( const bodypart_id &bp : bps ) {
4587 if( one_in( 2 ) ) {
4588 u.deal_damage( source, bp, damage_instance( DT_BASH, force_remaining * dam_mult ) );
4589 }
4590 }
4592 }
4593 m.bash( traj[i], 2 * dam_mult * force_remaining );
4594 break;
4595 } else if( critter_at( traj[i] ) ) {
4596 u.setpos( traj[i - 1] );
4597 force_remaining = traj.size() - i;
4598 if( stun != 0 ) {
4599 if( u.has_effect( effect_stunned ) ) {
4600 add_msg( m_bad, vgettext( "You were stunned AGAIN for %d turn!",
4601 "You were stunned AGAIN for %d turns!",
4602 force_remaining ),
4603 force_remaining );
4604 } else {
4605 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4606 "You were stunned for %d turns!",
4607 force_remaining ),
4608 force_remaining );
4609 }
4610 u.add_effect( effect_stunned, 1_turns * force_remaining );
4611 }
4612 traj.erase( traj.begin(), traj.begin() + i );
4613 if( critter_at<monster>( traj.front() ) ) {
4614 add_msg( _( "You collided with something and sent it flying!" ) );
4615 } else if( npc *const guy = critter_at<npc>( traj.front() ) ) {
4616 if( guy->male ) {
4617 add_msg( _( "You collided with someone and sent him flying!" ) );
4618 } else {
4619 add_msg( _( "You collided with someone and sent her flying!" ) );
4620 }
4621 }
4622 knockback( traj, stun, dam_mult, source );
4623 break;
4624 }
4625 if( m.has_flag( "LIQUID", u.pos() ) && force_remaining == 0 ) {
4626 avatar_action::swim( m, u, u.pos() );
4627 } else {
4628 u.setpos( traj[i] );
4629 }
4630
4631 tp = traj[i];
4632 }
4633 }
4634}
double footwear_factor() const
Returns 1 if the player is wearing something on both feet, .5 if on one, and 0 if on neither.
Definition: character.cpp:8940
dealt_damage_instance deal_damage(Creature *source, bodypart_id bp, const damage_instance &d) override
Calls Creature::deal_damage and handles damaged effects (waking up, etc.)
Definition: character.cpp:8468
void add_effect(const effect &eff, bool force=false, bool deferred=false)
Definition: creature.cpp:980
@ DT_BASH
Definition: damage.h:24
static const trait_id trait_LEG_TENT_BRACE("LEG_TENT_BRACE")
static const efftype_id effect_stunned("stunned")
@ MF_AQUATIC
Definition: mtype.h:89
void swim(map &m, avatar &you, const tripoint &p)
Handles swimming by the player.
const char * vgettext(const char *msgid, const char *msgid_plural, size_t n)

References _, Creature::add_effect(), add_msg(), map::bash(), Creature::check_dead_state(), critter_at(), Character::deal_damage(), debugmsg, DT_BASH, effect_stunned, Character::footwear_factor(), Creature::has_effect(), map::has_flag(), Character::has_trait(), map::impassable(), knockback(), m, m_bad, MF_AQUATIC, map::obstructed_by_vehicle_rotation(), one_in(), Character::pos(), Character::posx(), Character::posy(), Character::sees(), Character::setpos(), avatar_action::swim(), trait_LEG_TENT_BRACE, u, vgettext(), tripoint::x, tripoint::y, and tripoint::z.

◆ light_level()

unsigned char game::light_level ( int  zlev) const

Returns coarse number-of-squares of visibility at the current light level.

Used by monster and NPC AI.

Definition at line 3711 of file game.cpp.

3712{
3713 const float light = natural_light_level( zlev );
3714 return LIGHT_RANGE( light );
3715}
float natural_light_level(int zlev) const
Definition: game.cpp:3651
#define LIGHT_RANGE(b)
Definition: lightmap.h:41

References light, LIGHT_RANGE, and natural_light_level().

Referenced by calc_driving_offset(), and update_overmap_seen().

◆ list_active_characters()

std::vector< std::string > game::list_active_characters ( )

Returns a list of currently active character saves.

Definition at line 2918 of file game.cpp.

2919{
2920 std::vector<std::string> saves;
2921 for( auto &worldsave : world_generator->active_world->world_saves ) {
2922 saves.push_back( worldsave.player_name() );
2923 }
2924 return saves;
2925}

References world_generator.

Referenced by cleanup_at_end().

◆ list_items()

game::vmenu_ret game::list_items ( const std::vector< map_item_stack > &  item_list)
private

Definition at line 7380 of file game.cpp.

7381{
7382 std::vector<map_item_stack> ground_items = item_list;
7383 int iInfoHeight = 0;
7384 int iMaxRows = 0;
7385 int width = 0;
7386 int max_name_width = 0;
7387
7388 //find max length of item name and resize window width
7389 for( const map_item_stack &cur_item : ground_items ) {
7390 const int item_len = utf8_width( remove_color_tags( cur_item.example->display_name() ) ) + 15;
7391 if( item_len > max_name_width ) {
7392 max_name_width = item_len;
7393 }
7394 }
7395
7396 tripoint active_pos;
7397 map_item_stack *activeItem = nullptr;
7398
7399 catacurses::window w_items;
7400 catacurses::window w_items_border;
7401 catacurses::window w_item_info;
7402
7403 ui_adaptor ui;
7404 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
7405 iInfoHeight = std::min( 25, TERMY / 2 );
7406 iMaxRows = TERMY - iInfoHeight - 2;
7407
7408 width = clamp( max_name_width, 45, TERMX / 3 );
7409
7410 const int offsetX = TERMX - width;
7411
7412 w_items = catacurses::newwin( TERMY - 2 - iInfoHeight,
7413 width - 2, point( offsetX + 1, 1 ) );
7414 w_items_border = catacurses::newwin( TERMY - iInfoHeight,
7415 width, point( offsetX, 0 ) );
7416 w_item_info = catacurses::newwin( iInfoHeight, width,
7417 point( offsetX, TERMY - iInfoHeight ) );
7418
7419 if( activeItem ) {
7420 centerlistview( active_pos, width );
7421 }
7422
7423 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
7424 } );
7425 ui.mark_resize();
7426
7427 // use previously selected sorting method
7428 bool sort_radius = uistate.list_item_sort != 2;
7429 bool addcategory = !sort_radius;
7430
7431 // reload filter/priority settings on the first invocation, if they were active
7432 if( !uistate.list_item_init ) {
7435 }
7438 }
7441 }
7442 uistate.list_item_init = true;
7443 }
7444
7445 //this stores only those items that match our filter
7446 std::vector<map_item_stack> filtered_items =
7447 !sFilter.empty() ? filter_item_stacks( ground_items, sFilter ) : ground_items;
7448 int highPEnd = list_filter_high_priority( filtered_items, list_item_upvote );
7449 int lowPStart = list_filter_low_priority( filtered_items, highPEnd, list_item_downvote );
7450 int iItemNum = ground_items.size();
7451
7452 const tripoint stored_view_offset = u.view_offset;
7453
7455
7456 int iActive = 0; // Item index that we're looking at
7457 bool refilter = true;
7458 int page_num = 0;
7459 int iCatSortNum = 0;
7460 int iScrollPos = 0;
7461 std::map<int, std::string> mSortCategory;
7462
7463 std::string action;
7464 input_context ctxt( "LIST_ITEMS" );
7465 ctxt.register_action( "UP", to_translation( "Move cursor up" ) );
7466 ctxt.register_action( "DOWN", to_translation( "Move cursor down" ) );
7467 ctxt.register_action( "LEFT", to_translation( "Previous item" ) );
7468 ctxt.register_action( "RIGHT", to_translation( "Next item" ) );
7469 ctxt.register_action( "PAGE_DOWN" );
7470 ctxt.register_action( "PAGE_UP" );
7471 ctxt.register_action( "NEXT_TAB" );
7472 ctxt.register_action( "PREV_TAB" );
7473 ctxt.register_action( "HELP_KEYBINDINGS" );
7474 ctxt.register_action( "QUIT" );
7475 ctxt.register_action( "FILTER" );
7476 ctxt.register_action( "RESET_FILTER" );
7477 ctxt.register_action( "EXAMINE" );
7478 ctxt.register_action( "COMPARE" );
7479 ctxt.register_action( "PRIORITY_INCREASE" );
7480 ctxt.register_action( "PRIORITY_DECREASE" );
7481 ctxt.register_action( "SORT" );
7482 ctxt.register_action( "TRAVEL_TO" );
7483
7485
7486 ui.on_redraw( [&]( const ui_adaptor & ) {
7487 reset_item_list_state( w_items_border, iInfoHeight, sort_radius );
7488
7489 if( ground_items.empty() ) {
7490 wnoutrefresh( w_items_border );
7491 mvwprintz( w_items, point( 2, 10 ), c_white, _( "You don't see any items around you!" ) );
7492 } else {
7493 int iStartPos = 0;
7494 werase( w_items );
7495 calcStartPos( iStartPos, iActive, iMaxRows, iItemNum );
7496 int iNum = 0;
7497 bool high = false;
7498 bool low = false;
7499 int index = 0;
7500 int iCatSortOffset = 0;
7501
7502 for( int i = 0; i < iStartPos; i++ ) {
7503 if( !mSortCategory[i].empty() ) {
7504 iNum++;
7505 }
7506 }
7507 for( auto iter = filtered_items.begin(); iter != filtered_items.end(); ++index ) {
7508 if( highPEnd > 0 && index < highPEnd + iCatSortOffset ) {
7509 high = true;
7510 low = false;
7511 } else if( index >= lowPStart + iCatSortOffset ) {
7512 high = false;
7513 low = true;
7514 } else {
7515 high = false;
7516 low = false;
7517 }
7518
7519 if( iNum >= iStartPos && iNum < iStartPos + ( iMaxRows > iItemNum ? iItemNum : iMaxRows ) ) {
7520 int iThisPage = 0;
7521 if( !mSortCategory[iNum].empty() ) {
7522 iCatSortOffset++;
7523 mvwprintz( w_items, point( 1, iNum - iStartPos ), c_magenta, mSortCategory[iNum] );
7524 } else {
7525 if( iNum == iActive ) {
7526 iThisPage = page_num;
7527 }
7528 std::string sText;
7529 if( iter->vIG.size() > 1 ) {
7530 sText += string_format( "[%d/%d] (%d) ", iThisPage + 1, iter->vIG.size(), iter->totalcount );
7531 }
7532 sText += iter->example->tname();
7533 if( iter->vIG[iThisPage].count > 1 ) {
7534 sText += string_format( "[%d]", iter->vIG[iThisPage].count );
7535 }
7536
7537 nc_color col = c_light_green;
7538 if( iNum != iActive ) {
7539 if( high ) {
7540 col = c_yellow;
7541 } else if( low ) {
7542 col = c_red;
7543 } else {
7544 col = iter->example->color_in_inventory();
7545 }
7546 }
7547 trim_and_print( w_items, point( 1, iNum - iStartPos ), width - 9, col, sText );
7548 const int numw = iItemNum > 9 ? 2 : 1;
7549 const int x = iter->vIG[iThisPage].pos.x;
7550 const int y = iter->vIG[iThisPage].pos.y;
7551 mvwprintz( w_items, point( width - 6 - numw, iNum - iStartPos ),
7552 iNum == iActive ? c_light_green : c_light_gray,
7553 "%*d %s", numw, rl_dist( point_zero, point( x, y ) ),
7555 ++iter;
7556 }
7557 } else {
7558 ++iter;
7559 }
7560 iNum++;
7561 }
7562 iNum = 0;
7563 for( int i = 0; i < iActive; i++ ) {
7564 if( !mSortCategory[i].empty() ) {
7565 iNum++;
7566 }
7567 }
7568 mvwprintz( w_items_border, point( ( width - 9 ) / 2 + ( iItemNum > 9 ? 0 : 1 ), 0 ),
7569 c_light_green, " %*d", iItemNum > 9 ? 2 : 1, iItemNum > 0 ? iActive - iNum + 1 : 0 );
7570 wprintz( w_items_border, c_white, " / %*d ", iItemNum > 9 ? 2 : 1, iItemNum - iCatSortNum );
7571 werase( w_item_info );
7572
7573 if( iItemNum > 0 && activeItem ) {
7574 std::vector<iteminfo> vThisItem;
7575 std::vector<iteminfo> vDummy;
7576 activeItem->example->info( true, vThisItem );
7577
7578 item_info_data dummy( "", "", vThisItem, vDummy, iScrollPos );
7579 dummy.without_getch = true;
7580 dummy.without_border = true;
7581
7582 draw_item_info( w_item_info, dummy );
7583 }
7584 draw_scrollbar( w_items_border, iActive, iMaxRows, iItemNum, point_south );
7585 wnoutrefresh( w_items_border );
7586 }
7587
7588 const bool bDrawLeft = ground_items.empty() || filtered_items.empty() || !activeItem || filter_type;
7589 draw_custom_border( w_item_info, bDrawLeft, true, true, true, LINE_XXXO, LINE_XOXX, true, true );
7590
7591 if( iItemNum > 0 && activeItem ) {
7592 // print info window title: < item name >
7593 mvwprintw( w_item_info, point( 2, 0 ), "< " );
7594 trim_and_print( w_item_info, point( 4, 0 ), width - 8, activeItem->example->color_in_inventory(),
7595 activeItem->example->display_name() );
7596 wprintw( w_item_info, " >" );
7597 }
7598
7599 wnoutrefresh( w_items );
7600 wnoutrefresh( w_item_info );
7601
7602 if( filter_type ) {
7603 draw_item_filter_rules( w_item_info, 0, iInfoHeight - 1, filter_type.value() );
7604 }
7605 } );
7606
7607 cata::optional<tripoint> trail_start;
7608 cata::optional<tripoint> trail_end;
7609 bool trail_end_x = false;
7610 shared_ptr_fast<draw_callback_t> trail_cb = create_trail_callback( trail_start, trail_end,
7611 trail_end_x );
7612 add_draw_callback( trail_cb );
7613
7614 do {
7615 if( action == "COMPARE" && activeItem ) {
7616 game_menus::inv::compare( u, active_pos );
7617 } else if( action == "FILTER" ) {
7618 filter_type = item_filter_type::FILTER;
7619 ui.invalidate_ui();
7621 .title( _( "Filter:" ) )
7622 .width( 55 )
7623 .description( _( "UP: history, CTRL-U: clear line, ESC: abort, ENTER: save" ) )
7624 .identifier( "item_filter" )
7625 .max_length( 256 )
7626 .edit( sFilter );
7627 refilter = true;
7628 addcategory = !sort_radius;
7630 filter_type = cata::nullopt;
7631 } else if( action == "RESET_FILTER" ) {
7632 sFilter.clear();
7633 filtered_items = ground_items;
7634 refilter = true;
7636 addcategory = !sort_radius;
7637 } else if( action == "EXAMINE" && !filtered_items.empty() && activeItem ) {
7638 std::vector<iteminfo> vThisItem;
7639 std::vector<iteminfo> vDummy;
7640 activeItem->example->info( true, vThisItem );
7641
7642 item_info_data info_data( activeItem->example->tname(), activeItem->example->type_name(), vThisItem,
7643 vDummy );
7644 info_data.handle_scrolling = true;
7645
7647 return catacurses::newwin( TERMY, width - 5, point_zero );
7648 }, info_data );
7649 } else if( action == "PRIORITY_INCREASE" ) {
7650 filter_type = item_filter_type::HIGH_PRIORITY;
7651 ui.invalidate_ui();
7653 .title( _( "High Priority:" ) )
7654 .width( 55 )
7656 .description( _( "UP: history, CTRL-U clear line, ESC: abort, ENTER: save" ) )
7657 .identifier( "list_item_priority" )
7658 .max_length( 256 )
7659 .query_string();
7660 refilter = true;
7661 addcategory = !sort_radius;
7663 filter_type = cata::nullopt;
7664 } else if( action == "PRIORITY_DECREASE" ) {
7665 filter_type = item_filter_type::LOW_PRIORITY;
7666 ui.invalidate_ui();
7668 .title( _( "Low Priority:" ) )
7669 .width( 55 )
7671 .description( _( "UP: history, CTRL-U clear line, ESC: abort, ENTER: save" ) )
7672 .identifier( "list_item_downvote" )
7673 .max_length( 256 )
7674 .query_string();
7675 refilter = true;
7676 addcategory = !sort_radius;
7678 filter_type = cata::nullopt;
7679 } else if( action == "SORT" ) {
7680 if( sort_radius ) {
7681 sort_radius = false;
7682 addcategory = true;
7683 uistate.list_item_sort = 2; // list is sorted by category
7684 } else {
7685 sort_radius = true;
7686 uistate.list_item_sort = 1; // list is sorted by distance
7687 }
7688 highPEnd = -1;
7689 lowPStart = -1;
7690 iCatSortNum = 0;
7691
7692 mSortCategory.clear();
7693 refilter = true;
7694 } else if( action == "TRAVEL_TO" && activeItem ) {
7695 if( !u.sees( u.pos() + active_pos ) ) {
7696 add_msg( _( "You can't see that destination." ) );
7697 }
7698 auto route = m.route( u.pos(), u.pos() + active_pos, u.get_pathfinding_settings(),
7699 u.get_path_avoid() );
7700 if( route.size() > 1 ) {
7701 route.pop_back();
7702 u.set_destination( route );
7703 break;
7704 } else {
7705 add_msg( m_info, _( "You can't travel there." ) );
7706 }
7707 }
7708 if( uistate.list_item_sort == 1 ) {
7709 ground_items = item_list;
7710 } else if( uistate.list_item_sort == 2 ) {
7711 std::sort( ground_items.begin(), ground_items.end(), map_item_stack::map_item_stack_sort );
7712 }
7713
7714 if( refilter ) {
7715 refilter = false;
7716 filtered_items = filter_item_stacks( ground_items, sFilter );
7717 highPEnd = list_filter_high_priority( filtered_items, list_item_upvote );
7718 lowPStart = list_filter_low_priority( filtered_items, highPEnd, list_item_downvote );
7719 iActive = 0;
7720 page_num = 0;
7721 iItemNum = filtered_items.size();
7722 }
7723
7724 if( addcategory ) {
7725 addcategory = false;
7726 iCatSortNum = 0;
7727 mSortCategory.clear();
7728 if( highPEnd > 0 ) {
7729 mSortCategory[0] = _( "HIGH PRIORITY" );
7730 iCatSortNum++;
7731 }
7732 std::string last_cat_name;
7733 for( int i = std::max( 0, highPEnd );
7734 i < std::min( lowPStart, static_cast<int>( filtered_items.size() ) ); i++ ) {
7735 const std::string &cat_name = filtered_items[i].example->get_category().name();
7736 if( cat_name != last_cat_name ) {
7737 mSortCategory[i + iCatSortNum++] = cat_name;
7738 last_cat_name = cat_name;
7739 }
7740 }
7741 if( lowPStart < static_cast<int>( filtered_items.size() ) ) {
7742 mSortCategory[lowPStart + iCatSortNum++] = _( "LOW PRIORITY" );
7743 }
7744 if( !mSortCategory[0].empty() ) {
7745 iActive++;
7746 }
7747 iItemNum = static_cast<int>( filtered_items.size() ) + iCatSortNum;
7748 }
7749
7750 if( action == "UP" ) {
7751 do {
7752 iActive--;
7753
7754 } while( !mSortCategory[iActive].empty() );
7755 iScrollPos = 0;
7756 page_num = 0;
7757 if( iActive < 0 ) {
7758 iActive = iItemNum - 1;
7759 }
7760 } else if( action == "DOWN" ) {
7761 do {
7762 iActive++;
7763
7764 } while( !mSortCategory[iActive].empty() );
7765 iScrollPos = 0;
7766 page_num = 0;
7767 if( iActive >= iItemNum ) {
7768 iActive = mSortCategory[0].empty() ? 0 : 1;
7769 }
7770 } else if( action == "RIGHT" ) {
7771 if( !filtered_items.empty() && activeItem ) {
7772 if( ++page_num >= static_cast<int>( activeItem->vIG.size() ) ) {
7773 page_num = activeItem->vIG.size() - 1;
7774 }
7775 }
7776 } else if( action == "LEFT" ) {
7777 page_num = std::max( 0, page_num - 1 );
7778 } else if( action == "PAGE_UP" ) {
7779 iScrollPos--;
7780 } else if( action == "PAGE_DOWN" ) {
7781 iScrollPos++;
7782 } else if( action == "NEXT_TAB" || action == "PREV_TAB" ) {
7783 u.view_offset = stored_view_offset;
7785 }
7786
7787 active_pos = tripoint_zero;
7788 activeItem = nullptr;
7789
7790 if( mSortCategory[iActive].empty() ) {
7791 auto iter = filtered_items.begin();
7792 for( int iNum = 0; iter != filtered_items.end() && iNum < iActive; iNum++ ) {
7793 if( mSortCategory[iNum].empty() ) {
7794 ++iter;
7795 }
7796 }
7797 if( iter != filtered_items.end() ) {
7798 active_pos = iter->vIG[page_num].pos;
7799 activeItem = &( *iter );
7800 }
7801 }
7802
7803 if( activeItem ) {
7804 centerlistview( active_pos, width );
7805 trail_start = u.pos();
7806 trail_end = u.pos() + active_pos;
7807 // Actually accessed from the terrain overlay callback `trail_cb` in the
7808 // call to `ui_manager::redraw`.
7809 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
7810 trail_end_x = true;
7811 } else {
7812 u.view_offset = stored_view_offset;
7813 trail_start = trail_end = cata::nullopt;
7814 }
7816
7818
7819 action = ctxt.handle_input();
7820 } while( action != "QUIT" );
7821
7822 u.view_offset = stored_view_offset;
7823 return game::vmenu_ret::QUIT;
7824}
constexpr T clamp(const T &val, const T &min, const T &max)
Clamp first argument so that it is no lower than second and no higher than third.
Definition: cata_utility.h:145
std::string list_item_upvote
Definition: game.h:1057
std::string list_item_downvote
Definition: game.h:1058
std::string sFilter
Definition: game.h:1056
void reset_item_list_state(const catacurses::window &window, int height, bool bRadiusSort)
Definition: game.cpp:7267
std::string info(bool showtext=false) const
Return all the information about the item and its type.
Definition: item.cpp:1104
nc_color color_in_inventory() const
Returns the color of the item depending on usefulness for the player character, e....
Definition: item.cpp:4042
std::string type_name(unsigned int quantity=1) const
Name of the item type (not the item), with proper plural.
Definition: item.cpp:9699
std::string tname(unsigned int quantity=1, bool with_prefix=true, unsigned int truncate=0) const
Return the (translated) item name.
Definition: item.cpp:4465
static bool map_item_stack_sort(const map_item_stack &lhs, const map_item_stack &rhs)
std::vector< item_group > vIG
const item * example
string_input_popup & identifier(const std::string &value)
An identifier to be used to store / get the input history.
string_input_popup & text(const std::string &value)
Set / get the text that can be modified by the user.
void edit(std::string &value)
Edit values in place.
string_input_popup & width(int value)
Width (in console cells) of the input field itself.
string_input_popup & description(const std::string &value)
Additional help text, shown below the input box.
string_input_popup & title(const std::string &value)
The title: short string before the actual input field.
std::string list_item_priority
Definition: uistate.h:120
int list_item_sort
Definition: uistate.h:117
bool list_item_downvote_active
Definition: uistate.h:123
bool list_item_init
Definition: uistate.h:125
bool list_item_filter_active
Definition: uistate.h:122
std::string list_item_filter
Definition: uistate.h:118
bool list_item_priority_active
Definition: uistate.h:124
std::string list_item_downvote
Definition: uistate.h:119
direction direction_from(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:540
static shared_ptr_fast< game::draw_callback_t > create_trail_callback(const cata::optional< tripoint > &trail_start, const cata::optional< tripoint > &trail_end, const bool &trail_end_x)
Definition: game.cpp:3231
uistatedata uistate
Definition: game.cpp:276
static void centerlistview(const tripoint &active_item_position, int ui_width)
Definition: game.cpp:7112
std::string direction_name_short(const direction dir)
Definition: line.cpp:533
int list_filter_high_priority(std::vector< map_item_stack > &stack, const std::string &priorities)
std::vector< map_item_stack > filter_item_stacks(const std::vector< map_item_stack > &stack, const std::string &filter)
int list_filter_low_priority(std::vector< map_item_stack > &stack, const int start, const std::string &priorities)
void mvwprintw(const window &win, const point &p, const std::string &text)
void wprintw(const window &win, const std::string &text)
void calcStartPos(int &iStartPos, const int iCurrentLine, const int iContentHeight, const int iNumEntries)
Definition: output.cpp:1507
void draw_item_filter_rules(const catacurses::window &win, int starty, int height, item_filter_type type)
Write some tips (such as precede items with - to exclude them) onto the window.
Definition: output.cpp:810
void draw_scrollbar(const catacurses::window &window, const int iCurrentLine, const int iContentHeight, const int iNumLines, const point &offset, nc_color bar_color, const bool bDoNotScrollToEnd)
Draw a scrollbar (Legacy function, use class scrollbar instead!)
Definition: output.cpp:1314
std::string remove_color_tags(const std::string &s)
Removes the color tags from the input string.
Definition: output.cpp:145
void draw_custom_border(const catacurses::window &w, const catacurses::chtype ls, const catacurses::chtype rs, const catacurses::chtype ts, const catacurses::chtype bs, const catacurses::chtype tl, const catacurses::chtype tr, const catacurses::chtype bl, const catacurses::chtype br, const nc_color FG, const point &pos, int height, int width)
Definition: output.cpp:524
void trim_and_print(const catacurses::window &w, const point &begin, const int width, const nc_color &base_color, const std::string &text, const report_color_error color_error)
Prints a single line of text.
Definition: output.cpp:214
input_event draw_item_info(const int iLeft, const int iWidth, const int iTop, const int iHeight, item_info_data &data)
Definition: output.cpp:793
#define LINE_XOXX
Definition: output.h:47
#define LINE_XXXO
Definition: output.h:45

References _, action, add_draw_callback(), add_msg(), c_light_gray, c_light_green, c_magenta, c_red, c_white, c_yellow, calcStartPos(), centerlistview(), CHANGE_TAB, clamp(), item::color_in_inventory(), game_menus::inv::compare(), create_trail_callback(), string_input_popup::description(), direction_from(), direction_name_short(), item::display_name(), draw_custom_border(), draw_item_filter_rules(), draw_item_info(), draw_scrollbar(), string_input_popup::edit(), map_item_stack::example, FILTER, filter_item_stacks(), Character::get_path_avoid(), Character::get_pathfinding_settings(), input_context::handle_input(), item_info_data::handle_scrolling, high, HIGH_PRIORITY, string_input_popup::identifier(), item::info(), invalidate_main_ui_adaptor(), LINE_XOXX, LINE_XXXO, list_filter_high_priority(), list_filter_low_priority(), list_item_downvote, uistatedata::list_item_downvote, uistatedata::list_item_downvote_active, uistatedata::list_item_filter, uistatedata::list_item_filter_active, uistatedata::list_item_init, uistatedata::list_item_priority, uistatedata::list_item_priority_active, uistatedata::list_item_sort, list_item_upvote, LOW_PRIORITY, m, m_info, map_item_stack::map_item_stack_sort(), string_input_popup::max_length(), catacurses::mvwprintw(), mvwprintz(), catacurses::newwin(), cata::nullopt, point_south, point_zero, Character::pos(), string_input_popup::query_string(), QUIT, ui_manager::redraw(), input_context::register_action(), remove_color_tags(), reset_item_list_state(), rl_dist(), map::route(), Character::sees(), Character::set_destination(), sFilter, string_format(), TERMX, TERMY, string_input_popup::text(), string_input_popup::title(), item::tname(), to_translation(), trim_and_print(), tripoint_zero, item::type_name(), u, uistate, utf8_width(), cata::optional< T >::value(), player::view_offset, map_item_stack::vIG, catacurses::werase(), string_input_popup::width(), item_info_data::without_border, item_info_data::without_getch, catacurses::wnoutrefresh(), catacurses::wprintw(), and wprintz().

Referenced by list_items_monsters().

◆ list_items_monsters()

void game::list_items_monsters ( )
private

Definition at line 7335 of file game.cpp.

7336{
7337 std::vector<Creature *> mons = u.get_visible_creatures( current_daylight_level( calendar::turn ) );
7338 // whole reality bubble
7339 const std::vector<map_item_stack> items = find_nearby_items( 60 );
7340
7341 if( mons.empty() && items.empty() ) {
7342 add_msg( m_info, _( "You don't see any items or monsters around you!" ) );
7343 return;
7344 }
7345
7346 std::sort( mons.begin(), mons.end(), [&]( const Creature * lhs, const Creature * rhs ) {
7347 const auto att_lhs = lhs->attitude_to( u );
7348 const auto att_rhs = rhs->attitude_to( u );
7349
7350 return att_lhs < att_rhs || ( att_lhs == att_rhs
7351 && rl_dist( u.pos(), lhs->pos() ) < rl_dist( u.pos(), rhs->pos() ) );
7352 } );
7353
7354 // If the current list is empty, switch to the non-empty list
7356 if( items.empty() ) {
7357 uistate.vmenu_show_items = false;
7358 }
7359 } else if( mons.empty() ) {
7361 }
7362
7365 while( true ) {
7366 ret = uistate.vmenu_show_items ? list_items( items ) : list_monsters( mons );
7369 } else {
7370 break;
7371 }
7372 }
7373
7374 if( ret == game::vmenu_ret::FIRE ) {
7376 }
7378}
double current_daylight_level(const time_point &p)
Returns the current seasonally-adjusted maximum daylight level.
Definition: calendar.cpp:171
game::vmenu_ret list_monsters(const std::vector< Creature * > &monster_list)
Definition: game.cpp:7826
game::vmenu_ret list_items(const std::vector< map_item_stack > &item_list)
Definition: game.cpp:7380
vmenu_ret
Definition: game.h:795
std::vector< map_item_stack > find_nearby_items(int iRadius)
Definition: game.cpp:7035
void temp_exit_fullscreen()
Definition: game.cpp:552
void reenter_fullscreen()
Definition: game.cpp:562
bool vmenu_show_items
Definition: uistate.h:121

References _, add_msg(), CHANGE_TAB, current_daylight_level(), find_nearby_items(), FIRE, avatar_action::fire_wielded_weapon(), Character::get_visible_creatures(), list_items(), list_monsters(), m_info, reenter_fullscreen(), cata::hash64_detail::ret, temp_exit_fullscreen(), calendar::turn, u, uistate, and uistatedata::vmenu_show_items.

Referenced by handle_action(), and look_around().

◆ list_missions()

void game::list_missions ( )

Definition at line 22 of file mission_ui.cpp.

23{
24 catacurses::window w_missions;
25
26 enum class tab_mode : int {
27 TAB_ACTIVE = 0,
28 TAB_COMPLETED,
29 TAB_FAILED,
30 NUM_TABS,
31 FIRST_TAB = 0,
32 LAST_TAB = NUM_TABS - 1
33 };
34 tab_mode tab = tab_mode::FIRST_TAB;
35 size_t selection = 0;
36 int entries_per_page = 0;
37 input_context ctxt( "MISSIONS" );
38 ctxt.register_cardinal();
39 ctxt.register_action( "CONFIRM" );
40 ctxt.register_action( "QUIT" );
41 ctxt.register_action( "HELP_KEYBINDINGS" );
42
44 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
46
47 // content ranges from y=3 to FULL_SCREEN_HEIGHT - 2
48 entries_per_page = FULL_SCREEN_HEIGHT - 4;
49
50 ui.position_from_window( w_missions );
51 } );
52 ui.mark_resize();
53
54 std::vector<mission *> umissions;
55
56 ui.on_redraw( [&]( const ui_adaptor & ) {
57 werase( w_missions );
58 // entries_per_page * page number
59 const int top_of_page = entries_per_page * ( selection / entries_per_page );
60 const int bottom_of_page =
61 std::min( top_of_page + entries_per_page - 1, static_cast<int>( umissions.size() ) - 1 );
62
63 for( int i = 3; i < FULL_SCREEN_HEIGHT - 1; i++ ) {
64 mvwputch( w_missions, point( 30, i ), BORDER_COLOR, LINE_XOXO );
65 }
66
67 const std::vector<std::pair<tab_mode, std::string>> tabs = {
68 { tab_mode::TAB_ACTIVE, _( "ACTIVE MISSIONS" ) },
69 { tab_mode::TAB_COMPLETED, _( "COMPLETED MISSIONS" ) },
70 { tab_mode::TAB_FAILED, _( "FAILED MISSIONS" ) },
71 };
72 draw_tabs( w_missions, tabs, tab );
73 draw_border_below_tabs( w_missions );
74
75 mvwputch( w_missions, point( 30, 2 ), BORDER_COLOR,
76 tab == tab_mode::TAB_COMPLETED ? ' ' : LINE_OXXX ); // ^|^
77 mvwputch( w_missions, point( 30, FULL_SCREEN_HEIGHT - 1 ), BORDER_COLOR, LINE_XXOX ); // _|_
78
79 draw_scrollbar( w_missions, selection, entries_per_page, umissions.size(), point( 0, 3 ) );
80
81 for( int i = top_of_page; i <= bottom_of_page; i++ ) {
82 const auto miss = umissions[i];
83 const nc_color col = u.get_active_mission() == miss ? c_light_green : c_white;
84 const int y = i - top_of_page + 3;
85 trim_and_print( w_missions, point( 1, y ), 28,
86 static_cast<int>( selection ) == i ? hilite( col ) : col,
87 miss->name() );
88 }
89
90 if( selection < umissions.size() ) {
91 const auto miss = umissions[selection];
92 const nc_color col = u.get_active_mission() == miss ? c_light_green : c_white;
93 std::string for_npc;
94 if( miss->get_npc_id().is_valid() ) {
95 npc *guy = g->find_npc( miss->get_npc_id() );
96 if( guy ) {
97 for_npc = string_format( _( " for %s" ), guy->disp_name() );
98 }
99 }
100
101 int y = 3;
102 y += fold_and_print( w_missions, point( 31, y ), getmaxx( w_missions ) - 33, col,
103 miss->name() + for_npc );
104
105 auto format_tokenized_description = []( const std::string & description,
106 const std::vector<std::pair<int, itype_id>> &rewards ) {
107 std::string formatted_description = description;
108 for( const auto &reward : rewards ) {
109 std::string token = "<reward_count:" + reward.second.str() + ">";
110 formatted_description = replace_all( formatted_description, token,
111 string_format( "%d", reward.first ) );
112 }
113 return formatted_description;
114 };
115
116 y++;
117 if( !miss->get_description().empty() ) {
118 y += fold_and_print( w_missions, point( 31, y ), getmaxx( w_missions ) - 33, c_white,
119 format_tokenized_description( miss->get_description(), miss->get_likely_rewards() ) );
120 }
121 if( miss->has_deadline() ) {
122 const time_point deadline = miss->get_deadline();
123 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Deadline: %s" ), to_string( deadline ) );
124
125 if( tab != tab_mode::TAB_COMPLETED ) {
126 // There's no point in displaying this for a completed mission.
127 // @ TODO: But displaying when you completed it would be useful.
128 const time_duration remaining = deadline - calendar::turn;
129 std::string remaining_time;
130
131 if( remaining <= 0_turns ) {
132 remaining_time = _( "None!" );
133 } else if( u.has_watch() ) {
134 remaining_time = to_string( remaining );
135 } else {
136 remaining_time = to_string_approx( remaining );
137 }
138
139 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Time remaining: %s" ), remaining_time );
140 }
141 }
142 if( miss->has_target() ) {
144 // TODO: target does not contain a z-component, targets are assumed to be on z=0
145 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Target: %s You: %s" ),
146 miss->get_target().to_string(), pos.to_string() );
147 }
148 } else {
149 static const std::map< tab_mode, std::string > nope = {
150 { tab_mode::TAB_ACTIVE, translate_marker( "You have no active missions!" ) },
151 { tab_mode::TAB_COMPLETED, translate_marker( "You haven't completed any missions!" ) },
152 { tab_mode::TAB_FAILED, translate_marker( "You haven't failed any missions!" ) }
153 };
154 mvwprintz( w_missions, point( 31, 4 ), c_light_red, _( nope.at( tab ) ) );
155 }
156
157 wnoutrefresh( w_missions );
158 } );
159
160 while( true ) {
161 umissions.clear();
162 if( tab < tab_mode::FIRST_TAB || tab >= tab_mode::NUM_TABS ) {
163 debugmsg( "The sanity check failed because tab=%d", static_cast<int>( tab ) );
164 tab = tab_mode::FIRST_TAB;
165 }
166 switch( tab ) {
168 umissions = u.get_active_missions();
169 break;
170 case tab_mode::TAB_COMPLETED:
171 umissions = u.get_completed_missions();
172 break;
173 case tab_mode::TAB_FAILED:
174 umissions = u.get_failed_missions();
175 break;
176 default:
177 break;
178 }
179 if( ( !umissions.empty() && selection >= umissions.size() ) ||
180 ( umissions.empty() && selection != 0 ) ) {
181 debugmsg( "Sanity check failed: selection=%d, size=%d", static_cast<int>( selection ),
182 static_cast<int>( umissions.size() ) );
183 selection = 0;
184 }
186 const std::string action = ctxt.handle_input();
187 if( action == "RIGHT" ) {
188 tab = static_cast<tab_mode>( static_cast<int>( tab ) + 1 );
189 if( tab >= tab_mode::NUM_TABS ) {
190 tab = tab_mode::FIRST_TAB;
191 }
192 selection = 0;
193 } else if( action == "LEFT" ) {
194 tab = static_cast<tab_mode>( static_cast<int>( tab ) - 1 );
195 if( tab < tab_mode::FIRST_TAB ) {
196 tab = tab_mode::LAST_TAB;
197 }
198 selection = 0;
199 } else if( action == "DOWN" ) {
200 selection++;
201 if( selection >= umissions.size() ) {
202 selection = 0;
203 }
204 } else if( action == "UP" ) {
205 if( selection == 0 ) {
206 selection = umissions.empty() ? 0 : umissions.size() - 1;
207 } else {
208 selection--;
209 }
210 } else if( action == "CONFIRM" ) {
211 if( tab == tab_mode::TAB_ACTIVE && selection < umissions.size() ) {
212 u.set_active_mission( *umissions[selection] );
213 }
214 break;
215 } else if( action == "QUIT" ) {
216 break;
217 }
218 }
219}
std::string to_string_approx(const time_duration &dur, const bool verbose)
Returns approximate duration.
Definition: calendar.cpp:361
bool has_watch() const
Returns true if the player or their vehicle has a watch.
Definition: character.cpp:844
void set_active_mission(mission &cur_mission)
Set which mission is active.
Definition: avatar.cpp:211
mission * get_active_mission() const
Returns the mission that is currently active.
Definition: avatar.cpp:190
std::vector< mission * > get_completed_missions() const
Definition: avatar.cpp:180
std::vector< mission * > get_active_missions() const
Definition: avatar.cpp:175
std::vector< mission * > get_failed_missions() const
Definition: avatar.cpp:185
A point in the game time.
Definition: calendar.h:431
nc_color hilite(const nc_color &c)
Definition: color.cpp:509
void draw_tabs(const catacurses::window &w, const std::vector< std::string > &tab_texts, size_t current_tab)
Definition: output.cpp:1274
void draw_border_below_tabs(const catacurses::window &w, nc_color border_color)
Definition: output.cpp:587
int fold_and_print(const catacurses::window &w, const point &begin, int width, const nc_color &base_color, const std::string &text, const char split)
Fold and print text in the given window.
Definition: output.cpp:299
#define LINE_XXOX
Definition: output.h:46
#define BORDER_COLOR
Definition: output.h:135
std::string replace_all(std::string input, const std::string &what, const std::string &with)
Replace all occurences of 'what' within 'input' with 'with'.
#define translate_marker(x)
Marks a string literal to be extracted for translation.
Definition: translations.h:30
catacurses::window new_centered_win(int nlines, int ncols)
Definition: ui.cpp:30

References _, action, BORDER_COLOR, c_light_green, c_light_red, c_white, debugmsg, Character::disp_name(), draw_border_below_tabs(), draw_scrollbar(), draw_tabs(), fold_and_print(), FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, g, avatar::get_active_mission(), avatar::get_active_missions(), avatar::get_completed_missions(), avatar::get_failed_missions(), catacurses::getmaxx(), Character::global_omt_location(), input_context::handle_input(), Character::has_watch(), hilite(), LINE_OXXX, LINE_XOXO, LINE_XXOX, mvwprintz(), mvwputch(), new_centered_win(), ui_manager::redraw(), input_context::register_action(), input_context::register_cardinal(), replace_all(), avatar::set_active_mission(), string_format(), anonymous_namespace{bionics_ui.cpp}::TAB_ACTIVE, coords::coord_point< Point, Origin, Scale >::to_string(), to_string(), to_string_approx(), translate_marker, trim_and_print(), calendar::turn, u, catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by handle_action().

◆ list_monsters()

game::vmenu_ret game::list_monsters ( const std::vector< Creature * > &  monster_list)
private

Definition at line 7826 of file game.cpp.

7827{
7828 const int iInfoHeight = 15;
7829 const int width = 45;
7830 int offsetX = 0;
7831 int iMaxRows = 0;
7832
7833 catacurses::window w_monsters;
7834 catacurses::window w_monsters_border;
7835 catacurses::window w_monster_info;
7836 catacurses::window w_monster_info_border;
7837
7838 Creature *cCurMon = nullptr;
7839 tripoint iActivePos;
7840
7841 bool hide_ui = false;
7842
7843 ui_adaptor ui;
7844 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
7845 if( hide_ui ) {
7846 ui.position( point_zero, point_zero );
7847 } else {
7848 offsetX = TERMX - width;
7849 iMaxRows = TERMY - iInfoHeight - 1;
7850
7851 w_monsters = catacurses::newwin( iMaxRows, width - 2, point( offsetX + 1,
7852 1 ) );
7853 w_monsters_border = catacurses::newwin( iMaxRows + 1, width, point( offsetX,
7854 0 ) );
7855 w_monster_info = catacurses::newwin( iInfoHeight - 2, width - 2,
7856 point( offsetX + 1, TERMY - iInfoHeight + 1 ) );
7857 w_monster_info_border = catacurses::newwin( iInfoHeight, width, point( offsetX,
7858 TERMY - iInfoHeight ) );
7859
7860 if( cCurMon ) {
7861 centerlistview( iActivePos, width );
7862 }
7863
7864 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
7865 }
7866 } );
7867 ui.mark_resize();
7868
7869 const int max_gun_range = u.weapon.gun_range( &u );
7870
7871 const tripoint stored_view_offset = u.view_offset;
7873
7874 int iActive = 0; // monster index that we're looking at
7875
7876 std::string action;
7877 input_context ctxt( "LIST_MONSTERS" );
7878 ctxt.register_action( "UP", to_translation( "Move cursor up" ) );
7879 ctxt.register_action( "DOWN", to_translation( "Move cursor down" ) );
7880 ctxt.register_action( "NEXT_TAB" );
7881 ctxt.register_action( "PREV_TAB" );
7882 ctxt.register_action( "SAFEMODE_BLACKLIST_ADD" );
7883 ctxt.register_action( "SAFEMODE_BLACKLIST_REMOVE" );
7884 ctxt.register_action( "QUIT" );
7885 if( bVMonsterLookFire ) {
7886 ctxt.register_action( "look" );
7887 ctxt.register_action( "fire" );
7888 }
7889 ctxt.register_action( "HELP_KEYBINDINGS" );
7890
7891 // first integer is the row the attitude category string is printed in the menu
7892 std::map<int, Creature::Attitude> mSortCategory;
7893
7894 for( int i = 0, last_attitude = -1; i < static_cast<int>( monster_list.size() ); i++ ) {
7895 const auto attitude = monster_list[i]->attitude_to( u );
7896 if( attitude != last_attitude ) {
7897 mSortCategory[i + mSortCategory.size()] = attitude;
7898 last_attitude = attitude;
7899 }
7900 }
7901
7902 ui.on_redraw( [&]( const ui_adaptor & ) {
7903 if( !hide_ui ) {
7904 draw_custom_border( w_monsters_border, true, true, true, true, true, true, LINE_XOXO, LINE_XOXO );
7905 draw_custom_border( w_monster_info_border, true, true, true, true, LINE_XXXO, LINE_XOXX, true,
7906 true );
7907
7908 mvwprintz( w_monsters_border, point( 2, 0 ), c_light_green, "<Tab> " );
7909 wprintz( w_monsters_border, c_white, _( "Monsters" ) );
7910
7911 if( monster_list.empty() ) {
7912 werase( w_monsters );
7913 mvwprintz( w_monsters, point( 2, iMaxRows / 3 ), c_white,
7914 _( "You don't see any monsters around you!" ) );
7915 } else {
7916 werase( w_monsters );
7917
7918 const int iNumMonster = monster_list.size();
7919 const int iMenuSize = monster_list.size() + mSortCategory.size();
7920
7921 const int numw = iNumMonster > 999 ? 4 :
7922 iNumMonster > 99 ? 3 :
7923 iNumMonster > 9 ? 2 : 1;
7924
7925 // given the currently selected monster iActive. get the selected row
7926 int iSelPos = iActive;
7927 for( auto &ia : mSortCategory ) {
7928 int index = ia.first;
7929 if( index <= iSelPos ) {
7930 ++iSelPos;
7931 } else {
7932 break;
7933 }
7934 }
7935 int iStartPos = 0;
7936 // use selected row get the start row
7937 calcStartPos( iStartPos, iSelPos, iMaxRows - 1, iMenuSize );
7938
7939 // get first visible monster and category
7940 int iCurMon = iStartPos;
7941 auto CatSortIter = mSortCategory.cbegin();
7942 while( CatSortIter != mSortCategory.cend() && CatSortIter->first < iStartPos ) {
7943 ++CatSortIter;
7944 --iCurMon;
7945 }
7946
7947 const auto endY = std::min<int>( iMaxRows - 1, iMenuSize );
7948 for( int y = 0; y < endY; ++y ) {
7949 if( CatSortIter != mSortCategory.cend() ) {
7950 const int iCurPos = iStartPos + y;
7951 const int iCatPos = CatSortIter->first;
7952 if( iCurPos == iCatPos ) {
7953 const std::string cat_name = Creature::get_attitude_ui_data(
7954 CatSortIter->second ).first.translated();
7955 mvwprintz( w_monsters, point( 1, y ), c_magenta, cat_name );
7956 ++CatSortIter;
7957 continue;
7958 }
7959 }
7960 // select current monster
7961 const auto critter = monster_list[iCurMon];
7962 const bool selected = iCurMon == iActive;
7963 ++iCurMon;
7964 if( critter->sees( g->u ) ) {
7965 mvwprintz( w_monsters, point( 0, y ), c_yellow, "!" );
7966 }
7967 bool is_npc = false;
7968 const monster *m = dynamic_cast<monster *>( critter );
7969 const npc *p = dynamic_cast<npc *>( critter );
7970 nc_color name_color = critter->basic_symbol_color();
7971
7972 if( selected ) {
7973 name_color = hilite( name_color );
7974 }
7975
7976 if( m != nullptr ) {
7977 trim_and_print( w_monsters, point( 1, y ), width - 26, name_color, m->name() );
7978 } else {
7979 trim_and_print( w_monsters, point( 1, y ), width - 26, name_color, critter->disp_name() );
7980 is_npc = true;
7981 }
7982
7983 if( selected && !get_safemode().empty() ) {
7984 const std::string monName = is_npc ? get_safemode().npc_type_name() : m->name();
7985
7986 std::string sSafemode;
7987 if( get_safemode().has_rule( monName, Creature::A_ANY ) ) {
7988 sSafemode = _( "<R>emove from safemode Blacklist" );
7989 } else {
7990 sSafemode = _( "<A>dd to safemode Blacklist" );
7991 }
7992
7993 shortcut_print( w_monsters, point( 2, getmaxy( w_monsters ) - 1 ),
7994 c_white, c_light_green, sSafemode );
7995 }
7996
7998 std::string sText;
7999
8000 if( m != nullptr ) {
8001 m->get_HP_Bar( color, sText );
8002 } else {
8003 std::tie( sText, color ) =
8004 ::get_hp_bar( critter->get_hp(), critter->get_hp_max(), false );
8005 }
8006 mvwprintz( w_monsters, point( width - 25, y ), color, sText );
8007
8008 if( m != nullptr ) {
8009 const auto att = m->get_attitude();
8010 sText = att.first;
8011 color = att.second;
8012 } else if( p != nullptr ) {
8013 sText = npc_attitude_name( p->get_attitude() );
8014 color = p->symbol_color();
8015 }
8016 mvwprintz( w_monsters, point( width - 19, y ), color, sText );
8017
8018 const int mon_dist = rl_dist( u.pos(), critter->pos() );
8019 const int numd = mon_dist > 999 ? 4 :
8020 mon_dist > 99 ? 3 :
8021 mon_dist > 9 ? 2 : 1;
8022
8023 trim_and_print( w_monsters, point( width - ( 8 + numd ), y ), 6 + numd,
8024 selected ? c_light_green : c_light_gray,
8025 "%*d %s",
8026 numd, mon_dist,
8027 direction_name_short( direction_from( u.pos(), critter->pos() ) ) );
8028 }
8029
8030 mvwprintz( w_monsters_border, point( ( width / 2 ) - numw - 2, 0 ), c_light_green, " %*d", numw,
8031 iActive + 1 );
8032 wprintz( w_monsters_border, c_white, " / %*d ", numw, static_cast<int>( monster_list.size() ) );
8033
8034 werase( w_monster_info );
8035 if( cCurMon ) {
8036 cCurMon->print_info( w_monster_info, 1, iInfoHeight - 3, 1 );
8037 }
8038
8039 draw_custom_border( w_monster_info_border, true, true, true, true, LINE_XXXO, LINE_XOXX, true,
8040 true );
8041
8042 if( bVMonsterLookFire ) {
8043 mvwprintw( w_monster_info_border, point_east, "< " );
8044 wprintz( w_monster_info_border, c_light_green, ctxt.press_x( "look" ) );
8045 wprintz( w_monster_info_border, c_light_gray, " %s", _( "to look around" ) );
8046
8047 if( cCurMon && rl_dist( u.pos(), cCurMon->pos() ) <= max_gun_range ) {
8048 wprintw( w_monster_info_border, " " );
8049 wprintz( w_monster_info_border, c_light_green, ctxt.press_x( "fire" ) );
8050 wprintz( w_monster_info_border, c_light_gray, " %s", _( "to shoot" ) );
8051 }
8052 wprintw( w_monster_info_border, " >" );
8053 }
8054
8055 draw_scrollbar( w_monsters_border, iActive, iMaxRows, static_cast<int>( monster_list.size() ),
8056 point_south );
8057 }
8058
8059 wnoutrefresh( w_monsters_border );
8060 wnoutrefresh( w_monster_info_border );
8061 wnoutrefresh( w_monsters );
8062 wnoutrefresh( w_monster_info );
8063 }
8064 } );
8065
8066 cata::optional<tripoint> trail_start;
8067 cata::optional<tripoint> trail_end;
8068 bool trail_end_x = false;
8069 shared_ptr_fast<draw_callback_t> trail_cb = create_trail_callback( trail_start, trail_end,
8070 trail_end_x );
8071 add_draw_callback( trail_cb );
8072
8073 do {
8074 if( action == "UP" ) {
8075 iActive--;
8076 if( iActive < 0 ) {
8077 if( monster_list.empty() ) {
8078 iActive = 0;
8079 } else {
8080 iActive = static_cast<int>( monster_list.size() ) - 1;
8081 }
8082 }
8083 } else if( action == "DOWN" ) {
8084 iActive++;
8085 if( iActive >= static_cast<int>( monster_list.size() ) ) {
8086 iActive = 0;
8087 }
8088 } else if( action == "NEXT_TAB" || action == "PREV_TAB" ) {
8089 u.view_offset = stored_view_offset;
8091 } else if( action == "SAFEMODE_BLACKLIST_REMOVE" ) {
8092 const auto m = dynamic_cast<monster *>( cCurMon );
8093 const std::string monName = ( m != nullptr ) ? m->name() : "human";
8094
8095 if( get_safemode().has_rule( monName, Creature::A_ANY ) ) {
8097 }
8098 } else if( action == "SAFEMODE_BLACKLIST_ADD" ) {
8099 if( !get_safemode().empty() ) {
8100 const auto m = dynamic_cast<monster *>( cCurMon );
8101 const std::string monName = ( m != nullptr ) ? m->name() : "human";
8102
8103 get_safemode().add_rule( monName, Creature::A_ANY, get_option<int>( "SAFEMODEPROXIMITY" ),
8105 }
8106 } else if( action == "look" ) {
8107 hide_ui = true;
8108 ui.mark_resize();
8109 look_around();
8110 hide_ui = false;
8111 ui.mark_resize();
8112 } else if( action == "fire" ) {
8113 if( cCurMon != nullptr && rl_dist( u.pos(), cCurMon->pos() ) <= max_gun_range ) {
8114 u.last_target = shared_from( *cCurMon );
8116 u.view_offset = stored_view_offset;
8117 return game::vmenu_ret::FIRE;
8118 }
8119 }
8120
8121 if( iActive >= 0 && static_cast<size_t>( iActive ) < monster_list.size() ) {
8122 cCurMon = monster_list[iActive];
8123 iActivePos = cCurMon->pos() - u.pos();
8124 centerlistview( iActivePos, width );
8125 trail_start = u.pos();
8126 trail_end = cCurMon->pos();
8127 // Actually accessed from the terrain overlay callback `trail_cb` in the
8128 // call to `ui_manager::redraw`.
8129 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
8130 trail_end_x = false;
8131 } else {
8132 cCurMon = nullptr;
8133 iActivePos = tripoint_zero;
8134 u.view_offset = stored_view_offset;
8135 trail_start = trail_end = cata::nullopt;
8136 }
8138
8140
8141 action = ctxt.handle_input();
8142 } while( action != "QUIT" );
8143
8144 u.view_offset = stored_view_offset;
8145
8146 return game::vmenu_ret::QUIT;
8147}
double recoil
Definition: character.h:561
nc_color symbol_color() const override
Color's character's tile's background.
Definition: character.cpp:6109
static const std::pair< translation, nc_color > & get_attitude_ui_data(Attitude att)
Creature Attitude as String and color.
Definition: creature.cpp:1860
virtual const tripoint & pos() const =0
virtual int print_info(const catacurses::window &w, int vStart, int vLines, int column) const =0
Write information about this creature.
shared_ptr_fast< T > shared_from(const T &critter)
Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature).
Definition: game.cpp:4716
bool bVMonsterLookFire
Definition: game.h:1061
int gun_range(const player *p) const
The weapons range in map squares.
Definition: item.cpp:7222
npc_attitude get_attitude() const
Definition: npc.cpp:3139
weak_ptr_fast< Creature > last_target
Definition: player.h:597
bool has_rule(const std::string &rule_in, Creature::Attitude attitude_in)
void remove_rule(const std::string &rule_in, Creature::Attitude attitude_in)
static nc_color color(const T_t &t)
@ RULE_BLACKLISTED
Definition: enums.h:54
constexpr double MAX_RECOIL
std::string npc_attitude_name(npc_attitude att)
Definition: npc.cpp:2545
std::pair< std::string, nc_color > get_hp_bar(const int cur_hp, const int max_hp, const bool is_mon)
Definition: output.cpp:1604
size_t shortcut_print(const catacurses::window &w, const point &p, nc_color text_color, nc_color shortcut_color, const std::string &fmt)
Definition: output.cpp:1543

References _, Creature::A_ANY, action, add_draw_callback(), safemode::add_rule(), bVMonsterLookFire, c_light_gray, c_light_green, c_magenta, c_white, c_yellow, calcStartPos(), centerlistview(), CHANGE_TAB, color(), create_trail_callback(), direction_from(), direction_name_short(), draw_custom_border(), draw_scrollbar(), FIRE, g, npc::get_attitude(), Creature::get_attitude_ui_data(), get_hp_bar(), get_safemode(), catacurses::getmaxy(), item::gun_range(), input_context::handle_input(), safemode::has_rule(), hilite(), invalidate_main_ui_adaptor(), player::last_target, LINE_XOXO, LINE_XOXX, LINE_XXXO, look_around(), m, MAX_RECOIL, catacurses::mvwprintw(), mvwprintz(), map::name(), catacurses::newwin(), npc_attitude_name(), safemode::npc_type_name(), cata::nullopt, point_east, point_south, point_zero, Creature::pos(), Character::pos(), input_context::press_x(), Creature::print_info(), QUIT, Character::recoil, ui_manager::redraw(), input_context::register_action(), safemode::remove_rule(), rl_dist(), RULE_BLACKLISTED, shared_from(), shortcut_print(), Character::symbol_color(), TERMX, TERMY, to_translation(), trim_and_print(), tripoint_zero, u, player::view_offset, Character::weapon, catacurses::werase(), catacurses::wnoutrefresh(), catacurses::wprintw(), and wprintz().

Referenced by list_items_monsters().

◆ load() [1/2]

bool game::load ( const save_t name)
private

Definition at line 2639 of file game.cpp.

2640{
2643 popup.message( "%s", _( "Please wait…\nLoading the save…" ) );
2646
2647 using namespace std::placeholders;
2648
2649 const std::string worldpath = get_world_base_save_path() + "/";
2650 const std::string playerpath = worldpath + name.base_path();
2651
2652 // Now load up the master game data; factions (and more?)
2653 load_master();
2654 u = avatar();
2655 u.name = name.player_name();
2656 // This should be initialized more globally (in player/Character constructor)
2658 if( !read_from_file( playerpath + SAVE_EXTENSION, std::bind( &game::unserialize, this, _1 ) ) ) {
2659 return false;
2660 }
2661
2663
2665
2666 read_from_file_optional( worldpath + name.base_path() + SAVE_EXTENSION_LOG,
2667 std::bind( &memorial_logger::load, &memorial(), _1 ) );
2668
2669#if defined(__ANDROID__)
2670 read_from_file_optional( worldpath + name.base_path() + SAVE_EXTENSION_SHORTCUTS,
2671 std::bind( &game::load_shortcuts, this, _1 ) );
2672#endif
2673
2674 // Now that the player's worn items are updated, their sight limits need to be
2675 // recalculated. (This would be cleaner if u.worn were private.)
2677
2678 if( !gamemode ) {
2679 gamemode = std::make_unique<special_game>();
2680 }
2681
2682 safe_mode = get_option<bool>( "SAFEMODE" ) ? SAFE_MODE_ON : SAFE_MODE_OFF;
2683 mostseen = 0; // ...and mostseen is 0, we haven't seen any monsters yet.
2684
2685 init_autosave();
2686 get_auto_pickup().load_character(); // Load character auto pickup rules
2687 get_auto_notes_settings().load(); // Load character auto notes settings
2688 get_safemode().load_character(); // Load character safemode rules
2689 zone_manager::get_manager().load_zones(); // Load character world zones
2690 read_from_file_optional( get_world_base_save_path() + "/uistate.json", []( std::istream & stream ) {
2691 JsonIn jsin( stream );
2692 uistate.deserialize( jsin );
2693 } );
2694 reload_npcs();
2699 update_map( u );
2700 for( auto &e : u.inv_dump() ) {
2701 e->set_owner( g->u );
2702 }
2703 // legacy, needs to be here as we access the map.
2704 if( !u.getID().is_valid() ) {
2705 // player does not have a real id, so assign a new one,
2706 u.setID( assign_npc_id() );
2707 // The vehicle stores the IDs of the boarded players, so update it, too.
2708 if( u.in_vehicle ) {
2710 u.pos() ).part_with_feature( "BOARDABLE", true ) ) {
2711 vp->part().passenger_id = u.getID();
2712 }
2713 }
2714 }
2715
2716 // populate calendar caches now, after active world is set, but before we do
2717 // anything else, to ensure they pick up the correct value from the save's
2718 // worldoptions
2719 calendar::set_eternal_season( ::get_option<bool>( "ETERNAL_SEASON" ) );
2720 calendar::set_season_length( ::get_option<int>( "SEASON_LENGTH" ) );
2721
2722 u.reset();
2723
2724 return true;
2725}
bool read_from_file(const std::string &path, const std::function< void(std::istream &)> &reader)
Try to open and read from given file using the given callback.
bool read_from_file_optional(const std::string &path, const std::function< void(std::istream &)> &reader)
void setID(character_id i, bool force=false)
Definition: character.cpp:466
std::vector< item * > inv_dump()
Definition: character.cpp:8964
void recalc_sight_limits()
Modifies the player's sight values Must be called when any of the following change: This must be call...
Definition: character.cpp:1703
void reset() override
Handles stat and bonus reset.
Definition: character.cpp:3622
Definition: json.h:177
Definition: avatar.h:54
void load_map_memory()
Definition: avatar.cpp:134
Helper class that fills the background and obscures all UIs below.
Definition: ui_manager.h:193
bool is_valid() const
Definition: character_id.h:19
void validate_linked_vehicles()
validate towed vehicles so they get linked up again after a load
Definition: game.cpp:2003
void reload_npcs()
Unloads, then loads the NPCs.
Definition: game.cpp:976
void validate_camps()
validate camps to ensure they are on the overmap list
Definition: game.cpp:2061
void load_master()
Definition: game.cpp:2608
void validate_mounted_npcs()
Definition: game.cpp:2018
character_id assign_npc_id()
Definition: game.cpp:3725
void unserialize(std::istream &fin)
Definition: savegame.cpp:167
void init_autosave()
Definition: game.cpp:11365
void validate_npc_followers()
validate list of followers to account for overmap buffers
Definition: game.cpp:2037
void load(std::istream &fin)
Loads the data in a memorial file from the given ifstream.
void load_character()
Create a popup on the UI stack that gets displayed but receives no input itself.
Definition: popup.h:278
void deserialize(const JsonObject &jo)
time_point nextweather
Definition: weather.h:205
void load_zones()
Definition: clzones.cpp:1216
static const std::string SAVE_EXTENSION(".sav")
static const std::string SAVE_EXTENSION_SHORTCUTS(".shortcuts")
static const std::string SAVE_EXTENSION_LOG(".log")
void set_season_length(int dur)
Definition: calendar.cpp:478
void set_eternal_season(bool is_eternal_season)
Definition: calendar.cpp:470

References _, assign_npc_id(), uistatedata::deserialize(), g, gamemode, get_auto_notes_settings(), get_auto_pickup(), zone_manager::get_manager(), get_safemode(), get_weather, get_world_base_save_path(), Character::getID(), Character::in_vehicle, init_autosave(), Character::inv_dump(), character_id::is_valid(), auto_notes::auto_note_settings::load(), memorial_logger::load(), auto_pickup::player_settings::load_character(), safemode::load_character(), avatar::load_map_memory(), load_master(), zone_manager::load_zones(), m, memorial(), mostseen, Character::name, om_direction::name(), weather_manager::nextweather, optional_vpart_position::part_with_feature(), popup(), Character::pos(), read_from_file(), read_from_file_optional(), Character::recalc_sight_limits(), ui_manager::redraw(), refresh_display(), reload_npcs(), Character::reset(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAVE_EXTENSION(), SAVE_EXTENSION_LOG(), SAVE_EXTENSION_SHORTCUTS(), calendar::set_eternal_season(), calendar::set_season_length(), Character::setID(), calendar::start_of_cataclysm, calendar::turn, u, uistate, unserialize(), update_map(), validate_camps(), validate_linked_vehicles(), validate_mounted_npcs(), validate_npc_followers(), map::veh_at(), and Character::weapon.

◆ load() [2/2]

bool game::load ( const std::string &  world)

Attempt to load first valid save (if any) in world.

Definition at line 2615 of file game.cpp.

2616{
2617 world_generator->init();
2618 const WORLDPTR wptr = world_generator->get_world( world );
2619 if( !wptr ) {
2620 return false;
2621 }
2622 if( wptr->world_saves.empty() ) {
2623 debugmsg( "world '%s' contains no saves", world );
2624 return false;
2625 }
2626
2627 try {
2628 world_generator->set_active_world( wptr );
2629 g->setup();
2630 g->load( wptr->world_saves.front() );
2631 } catch( const std::exception &err ) {
2632 debugmsg( "cannot load world '%s': %s", world, err.what() );
2633 return false;
2634 }
2635
2636 return true;
2637}
std::vector< save_t > world_saves
Definition: worldfactory.h:61

References debugmsg, g, world_generator, and WORLD::world_saves.

Referenced by quickload().

◆ load_core_data()

void game::load_core_data ( loading_ui ui)

Loads core dynamic data.

May throw.

Definition at line 443 of file game.cpp.

444{
445 // core data can be loaded only once and must be first
446 // anyway.
448
450}
void unload_data()
Deletes and unloads all the data previously loaded with load_data_from_path.
Definition: init.cpp:531
std::string jsondir()
Definition: path_info.cpp:230

References DynamicDataLoader::get_instance(), PATH_INFO::jsondir(), load_data_from_dir(), and DynamicDataLoader::unload_data().

Referenced by check_mod_data(), dump_stats(), and setup().

◆ load_data_from_dir()

void game::load_data_from_dir ( const std::string &  path,
const std::string &  src,
loading_ui ui 
)
protected

Loads dynamic data from the given directory.

May throw.

Definition at line 452 of file game.cpp.

453{
455}
void load_data_from_path(const std::string &path, const std::string &src, loading_ui &ui)
Load all data from json files located in the path (recursive).
Definition: init.cpp:460

References DynamicDataLoader::get_instance(), and DynamicDataLoader::load_data_from_path().

Referenced by check_mod_data(), load_core_data(), and load_packs().

◆ load_map() [1/2]

void game::load_map ( const tripoint pos_sm,
bool  pump_events = false 
)

Load the main map at given location, see map::load, in global, absolute submap coordinates.

Parameters
pump_eventsIf true, handle window events during loading. If you set this to true, do ensure that the map is not accessed before this function returns (for example, UIs that draw the map should be disabled).

Definition at line 648 of file game.cpp.

649{
650 // TODO: fix point types
651 load_map( tripoint_abs_sm( pos_sm ), pump_events );
652}
void load_map(const tripoint &pos_sm, bool pump_events=false)
Load the main map at given location, see map::load, in global, absolute submap coordinates.
Definition: game.cpp:648
coords::coord_point< tripoint, coords::origin::abs, coords::sm > tripoint_abs_sm
Definition: coordinates.h:490

References load_map().

Referenced by load_map(), place_player_overmap(), start_game(), and unserialize().

◆ load_map() [2/2]

void game::load_map ( const tripoint_abs_sm pos_sm,
bool  pump_events = false 
)

Definition at line 654 of file game.cpp.

656{
657 m.load( pos_sm, true, pump_events );
658 grid_tracker_ptr->load( m );
659}
void load(const tripoint &w, bool update_vehicles, bool pump_events=false)
Load submaps into grid.
Definition: map.cpp:6609

References grid_tracker_ptr, map::load(), and m.

◆ load_master()

void game::load_master ( )
private

Definition at line 2608 of file game.cpp.

2609{
2610 using namespace std::placeholders;
2611 const auto datafile = get_world_base_save_path() + "/" + SAVE_MASTER;
2612 read_from_file_optional( datafile, std::bind( &game::unserialize_master, this, _1 ) );
2613}
void unserialize_master(std::istream &fin)
Definition: savegame.cpp:1193
static const std::string SAVE_MASTER("master.gsav")

References get_world_base_save_path(), read_from_file_optional(), SAVE_MASTER(), and unserialize_master().

Referenced by load(), and start_game().

◆ load_npcs()

void game::load_npcs ( )

Makes any nearby NPCs on the overmap active.

Definition at line 914 of file game.cpp.

915{
916 const int radius = HALF_MAPSIZE - 1;
917 // uses submap coordinates
918 std::vector<shared_ptr_fast<npc>> just_added;
919 for( const auto &temp : overmap_buffer.get_npcs_near_player( radius ) ) {
920 const character_id &id = temp->getID();
921 const auto found = std::find_if( active_npc.begin(), active_npc.end(),
922 [id]( const shared_ptr_fast<npc> &n ) {
923 return n->getID() == id;
924 } );
925 if( found != active_npc.end() ) {
926 continue;
927 }
928 if( temp->is_active() ) {
929 continue;
930 }
931 if( temp->has_companion_mission() ) {
932 continue;
933 }
934
935 const tripoint sm_loc = temp->global_sm_location();
936 // NPCs who are out of bounds before placement would be pushed into bounds
937 // This can cause NPCs to teleport around, so we don't want that
938 if( sm_loc.x < get_levx() || sm_loc.x >= get_levx() + MAPSIZE ||
939 sm_loc.y < get_levy() || sm_loc.y >= get_levy() + MAPSIZE ||
940 ( sm_loc.z != get_levz() && !m.has_zlevels() ) ) {
941 continue;
942 }
943
944 add_msg( m_debug, "game::load_npcs: Spawning static NPC, %d:%d:%d (%d:%d:%d)",
945 get_levx(), get_levy(), get_levz(), sm_loc.x, sm_loc.y, sm_loc.z );
946 temp->place_on_map();
947 if( !m.inbounds( temp->pos() ) ) {
948 continue;
949 }
950 // In the rare case the npc was marked for death while
951 // it was on the overmap. Kill it.
952 if( temp->marked_for_death ) {
953 temp->die( nullptr );
954 } else {
955 active_npc.push_back( temp );
956 just_added.push_back( temp );
957 }
958 }
959
960 for( const auto &npc : just_added ) {
961 npc->on_load();
962 }
963
964 npcs_dirty = false;
965}
void on_load()
Retroactively update npc.
Definition: npc.cpp:2658
static constexpr int MAPSIZE

References active_npc, add_msg(), get_levx(), get_levy(), get_levz(), overmapbuffer::get_npcs_near_player(), HALF_MAPSIZE, map::has_zlevels(), map::inbounds(), m, m_debug, MAPSIZE, npcs_dirty, npc::on_load(), overmap_buffer, tripoint::x, tripoint::y, and tripoint::z.

Referenced by do_turn(), perhaps_add_random_npc(), place_player_overmap(), reload_npcs(), save_cyborg(), spawn_hallucination(), start_game(), and update_map().

◆ load_packs()

bool game::load_packs ( const std::string &  msg,
const std::vector< mod_id > &  packs,
loading_ui ui 
)

Load content packs.

Parameters
msgstring to display whilst loading prompt
packscontent packs to load in correct dependent order
uistructure for load progress display
Returns
true if all packs were found, false if any were missing

Definition at line 2763 of file game.cpp.

2764{
2765 ui.new_context( msg );
2766 std::vector<mod_id> missing;
2767 std::vector<mod_id> available;
2768
2769 for( const mod_id &e : packs ) {
2770 if( e.is_valid() ) {
2771 available.emplace_back( e );
2772 ui.add_entry( e->name() );
2773 } else {
2774 missing.push_back( e );
2775 }
2776 }
2777
2778 ui.show();
2779 for( const auto &e : available ) {
2780 const MOD_INFORMATION &mod = *e;
2781 load_data_from_dir( mod.path, mod.ident.str(), ui );
2782 ui.proceed();
2783 }
2784
2785 for( const auto &e : missing ) {
2786 debugmsg( "unknown content %s", e.c_str() );
2787 }
2788
2789 return missing.empty();
2790}

References available, string_id< T >::c_str(), debugmsg, string_id< T >::is_valid(), load_data_from_dir(), and MOD_INFORMATION::name().

Referenced by dump_stats().

◆ load_static_data()

void game::load_static_data ( )

Loads static data that does not depend on mods or similar.

Definition at line 328 of file game.cpp.

329{
330 // UI stuff, not mod-specific per definition
331 inp_mngr.init(); // Load input config JSON
332 // Init mappings for loading the json stuff
334 fullscreen = false;
335 was_fullscreen = false;
336 show_panel_adm = false;
338
339 // These functions do not load stuff from json.
340 // The content they load/initialize is hardcoded into the program.
341 // Therefore they can be loaded here.
342 // If this changes (if they load data from json), they have to
343 // be moved to game::load_mod or game::load_core_data
344
348}
bool was_fullscreen
Definition: game.h:1043
bool fullscreen
Definition: game.h:1042
void init()
Initializes the input manager, aka loads the input mapping configuration JSON.
Definition: input.cpp:111
void init()
Definition: panels.cpp:2186
void load_global()

References fullscreen, get_auto_pickup(), get_distraction_manager(), DynamicDataLoader::get_instance(), panel_manager::get_manager(), get_safemode(), input_manager::init(), panel_manager::init(), inp_mngr, distraction_manager::distraction_manager_gui::load(), auto_pickup::player_settings::load_global(), safemode::load_global(), show_panel_adm, and was_fullscreen.

◆ load_world_modfiles()

void game::load_world_modfiles ( loading_ui ui)

Loads core data and mods from the active world.

May throw.

Definition at line 2727 of file game.cpp.

2728{
2729 auto &mods = world_generator->active_world->active_mod_order;
2730
2731 // remove any duplicates whilst preserving order (fixes #19385)
2732 std::set<mod_id> found;
2733 mods.erase( std::remove_if( mods.begin(), mods.end(), [&found]( const mod_id & e ) {
2734 if( found.count( e ) ) {
2735 return true;
2736 } else {
2737 found.insert( e );
2738 return false;
2739 }
2740 } ), mods.end() );
2741
2742 // require at least one core mod (saves before version 6 may implicitly require dda pack)
2743 if( std::none_of( mods.begin(), mods.end(), []( const mod_id & e ) {
2744 return e->core;
2745} ) ) {
2746 mods.insert( mods.begin(), mod_id( "dda" ) );
2747 }
2748
2750 // this code does not care about mod dependencies,
2751 // it assumes that those dependencies are static and
2752 // are resolved during the creation of the world.
2753 // That means world->active_mod_order contains a list
2754 // of mods in the correct order.
2755 load_packs( _( "Loading files" ), mods, ui );
2756
2757 // Load additional mods from that world-specific folder
2758 load_data_from_dir( get_world_base_save_path() + "/mods", "custom", ui );
2759
2761}
void load_artifacts(const std::string &path)
Definition: artifact.cpp:1098
static const std::string SAVE_ARTIFACTS("artifacts.gsav")

References world_generator.

Referenced by setup().

◆ look_around() [1/2]

cata::optional< tripoint > game::look_around ( bool  force_3d = false)

Definition at line 6683 of file game.cpp.

6684{
6686 look_around_result result = look_around( /*show_window=*/true, center, center, false, false,
6687 false, false, tripoint_zero, force_3d );
6688 return result.position;
6689}

References center, look_around(), Character::pos(), tripoint_zero, u, and player::view_offset.

Referenced by handle_action(), list_monsters(), look_around(), peek(), and zones_manager().

◆ look_around() [2/2]

look_around_result game::look_around ( bool  show_window,
tripoint center,
const tripoint start_point,
bool  has_first_point,
bool  select_zone,
bool  peeking,
bool  is_moving_zone = false,
const tripoint end_point = tripoint_zero,
bool  force_3d = false 
)
Parameters
show_windowdisplay the info window that holds the tile information in the position.
centerused to calculate the u.view_offset, could center the screen to the position it represents
start_pointthe start point of the targeting zone, also the initial local position of the cursor
has_first_pointshould be true if the first point has been selected when editing the zone
select_zonetrue if the zone is being edited
peekingdetermines if the player is peeking
is_moving_zonetrue if the zone is being moved, false by default
end_pointthe end point of the targeting zone, only used if is_moving_zone is true, default is tripoint_zero
Returns
look_around_result

Definition at line 6691 of file game.cpp.

6694{
6695 bVMonsterLookFire = false;
6696 // TODO: Make this `true`
6697 const bool allow_zlev_move = m.has_zlevels() && ( get_option<bool>( "FOV_3D" ) || force_3d );
6698
6700
6701 tripoint lp = is_moving_zone ? ( start_point + end_point ) / 2 : start_point; // cursor
6702 int &lx = lp.x;
6703 int &ly = lp.y;
6704 int &lz = lp.z;
6705
6706 int soffset = get_option<int>( "FAST_SCROLL_OFFSET" );
6707 bool fast_scroll = false;
6708
6709 std::unique_ptr<ui_adaptor> ui;
6710 catacurses::window w_info;
6711 if( show_window ) {
6712 ui = std::make_unique<ui_adaptor>();
6713 ui->on_screen_resize( [&]( ui_adaptor & ui ) {
6714 int panel_width = panel_manager::get_manager().get_current_layout().begin()->get_width();
6716
6717 // If particularly small, base height on panel width irrespective of other elements.
6718 // Value here is attempting to get a square-ish result assuming 1x2 proportioned font.
6719 if( height < panel_width / 2 ) {
6720 height = panel_width / 2;
6721 }
6722
6723 int la_y = 0;
6724 int la_x = TERMX - panel_width;
6725 std::string position = get_option<std::string>( "LOOKAROUND_POSITION" );
6726 if( position == "left" ) {
6727 if( get_option<std::string>( "SIDEBAR_POSITION" ) == "right" ) {
6729 } else {
6730 la_x = panel_manager::get_manager().get_width_left() - panel_width;
6731 }
6732 }
6733 int la_h = height;
6734 int la_w = panel_width;
6735 w_info = catacurses::newwin( la_h, la_w, point( la_x, la_y ) );
6736
6737 ui.position_from_window( w_info );
6738 } );
6739 ui->mark_resize();
6740 }
6741
6742 std::string action;
6743 input_context ctxt( "LOOK" );
6744 ctxt.set_iso( true );
6745 ctxt.register_directions();
6746 ctxt.register_action( "COORDINATE" );
6747 ctxt.register_action( "LEVEL_UP" );
6748 ctxt.register_action( "LEVEL_DOWN" );
6749 ctxt.register_action( "TOGGLE_FAST_SCROLL" );
6750 ctxt.register_action( "EXTENDED_DESCRIPTION" );
6751 ctxt.register_action( "SELECT" );
6752 if( peeking ) {
6753 ctxt.register_action( "throw_blind" );
6754 }
6755 if( !select_zone ) {
6756 ctxt.register_action( "TRAVEL_TO" );
6757 ctxt.register_action( "LIST_ITEMS" );
6758 }
6759 ctxt.register_action( "MOUSE_MOVE" );
6760 ctxt.register_action( "CENTER" );
6761
6762 ctxt.register_action( "debug_scent" );
6763 ctxt.register_action( "debug_scent_type" );
6764 ctxt.register_action( "debug_temp" );
6765 ctxt.register_action( "debug_visibility" );
6766 ctxt.register_action( "debug_lighting" );
6767 ctxt.register_action( "debug_radiation" );
6768 ctxt.register_action( "debug_submap_grid" );
6769 ctxt.register_action( "debug_hour_timer" );
6770 ctxt.register_action( "CONFIRM" );
6771 ctxt.register_action( "QUIT" );
6772 ctxt.register_action( "HELP_KEYBINDINGS" );
6773 if( use_tiles ) {
6774 ctxt.register_action( "zoom_out" );
6775 ctxt.register_action( "zoom_in" );
6776 }
6777#if defined(TILES)
6778 ctxt.register_action( "toggle_pixel_minimap" );
6779#endif // TILES
6780
6781 const int old_levz = get_levz();
6782 const int min_levz = force_3d ? -OVERMAP_DEPTH : std::max( old_levz - fov_3d_z_range,
6783 -OVERMAP_DEPTH );
6784 const int max_levz = force_3d ? OVERMAP_HEIGHT : std::min( old_levz + fov_3d_z_range,
6786
6787 m.update_visibility_cache( old_levz );
6789
6790 bool blink = true;
6792
6793 shared_ptr_fast<draw_callback_t> ter_indicator_cb;
6794
6795 if( show_window && ui ) {
6796 ui->on_redraw( [&]( const ui_adaptor & ) {
6797 werase( w_info );
6798 draw_border( w_info );
6799
6800 center_print( w_info, 0, c_white, string_format( _( "< <color_green>Look Around</color> >" ) ) );
6801
6802 std::string extended_descr_text = string_format( _( "%s - %s" ),
6803 ctxt.get_desc( "EXTENDED_DESCRIPTION" ),
6804 ctxt.get_action_name( "EXTENDED_DESCRIPTION" ) );
6805 std::string fast_scroll_text = string_format( _( "%s - %s" ),
6806 ctxt.get_desc( "TOGGLE_FAST_SCROLL" ),
6807 ctxt.get_action_name( "TOGGLE_FAST_SCROLL" ) );
6808#if defined(TILES)
6809 std::string pixel_minimap_text = string_format( _( "%s - %s" ),
6810 ctxt.get_desc( "toggle_pixel_minimap" ),
6811 ctxt.get_action_name( "toggle_pixel_minimap" ) );
6812#endif // TILES
6813
6814 center_print( w_info, getmaxy( w_info ) - 2, c_light_gray, extended_descr_text );
6815 mvwprintz( w_info, point( 1, getmaxy( w_info ) - 1 ), fast_scroll ? c_light_green : c_green,
6816 fast_scroll_text );
6817#if defined(TILES)
6818 right_print( w_info, getmaxy( w_info ) - 1, 1, pixel_minimap_option ? c_light_green : c_green,
6819 pixel_minimap_text );
6820#endif // TILES
6821
6822 int first_line = 1;
6823 const int last_line = getmaxy( w_info ) - 3;
6824 pre_print_all_tile_info( lp, w_info, first_line, last_line, cache );
6825
6826 wnoutrefresh( w_info );
6827 } );
6828 ter_indicator_cb = make_shared_fast<draw_callback_t>( [&]() {
6829 draw_look_around_cursor( lp, cache );
6830 } );
6831 add_draw_callback( ter_indicator_cb );
6832 }
6833
6834 cata::optional<tripoint> zone_start;
6835 cata::optional<tripoint> zone_end;
6836 bool zone_blink = false;
6837 bool zone_cursor = true;
6838 shared_ptr_fast<draw_callback_t> zone_cb = create_zone_callback( zone_start, zone_end, zone_blink,
6839 zone_cursor, is_moving_zone );
6840 add_draw_callback( zone_cb );
6841
6842 is_looking = true;
6843 const tripoint prev_offset = u.view_offset;
6844#if defined(TILES)
6845 const int prev_tileset_zoom = tileset_zoom;
6846 while( is_moving_zone && square_dist( start_point, end_point ) > 256 / get_zoom() &&
6847 get_zoom() != 4 ) {
6848 zoom_out();
6849 }
6851#endif
6852 do {
6853 u.view_offset = center - u.pos();
6854 if( select_zone ) {
6855 if( has_first_point ) {
6856 zone_start = start_point;
6857 zone_end = lp;
6858 } else {
6859 zone_start = lp;
6860 zone_end = cata::nullopt;
6861 }
6862 // Actually accessed from the terrain overlay callback `zone_cb` in the
6863 // call to `ui_manager::redraw`.
6864 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
6865 zone_blink = blink;
6866 }
6867
6868 if( is_moving_zone ) {
6869 zone_start = lp - ( start_point + end_point ) / 2 + start_point;
6870 zone_end = lp - ( start_point + end_point ) / 2 + end_point;
6871 // Actually accessed from the terrain overlay callback `zone_cb` in the
6872 // call to `ui_manager::redraw`.
6873 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
6874 zone_blink = blink;
6875 }
6878 if( ( select_zone && has_first_point ) || is_moving_zone ) {
6879 ctxt.set_timeout( BLINK_SPEED );
6880 }
6881
6882 //Wait for input
6883 // only specify a timeout here if "EDGE_SCROLL" is enabled
6884 // otherwise use the previously set timeout
6885 const tripoint edge_scroll = mouse_edge_scrolling_terrain( ctxt );
6886 const int scroll_timeout = get_option<int>( "EDGE_SCROLL" );
6887 const bool edge_scrolling = edge_scroll != tripoint_zero && scroll_timeout >= 0;
6888 if( edge_scrolling ) {
6889 action = ctxt.handle_input( scroll_timeout );
6890 } else {
6891 action = ctxt.handle_input();
6892 }
6893 if( ( action == "LEVEL_UP" || action == "LEVEL_DOWN" || action == "MOUSE_MOVE" ||
6894 ctxt.get_direction( action ) ) && ( ( select_zone && has_first_point ) || is_moving_zone ) ) {
6895 blink = true; // Always draw blink symbols when moving cursor
6896 } else if( action == "TIMEOUT" ) {
6897 blink = !blink;
6898 }
6899 if( action == "LIST_ITEMS" ) {
6901 } else if( action == "TOGGLE_FAST_SCROLL" ) {
6902 fast_scroll = !fast_scroll;
6903 } else if( action == "toggle_pixel_minimap" ) {
6905
6906 if( show_window && ui ) {
6907 ui->mark_resize();
6908 }
6909 } else if( action == "LEVEL_UP" || action == "LEVEL_DOWN" ) {
6910 if( !allow_zlev_move ) {
6911 continue;
6912 }
6913
6914 const int dz = ( action == "LEVEL_UP" ? 1 : -1 );
6915 lz = clamp( lz + dz, min_levz, max_levz );
6916 center.z = clamp( center.z + dz, min_levz, max_levz );
6917
6918 add_msg( m_debug, "levx: %d, levy: %d, levz: %d", get_levx(), get_levy(), center.z );
6919 u.view_offset.z = center.z - u.posz();
6921 } else if( action == "TRAVEL_TO" ) {
6922 if( !u.sees( lp ) ) {
6923 add_msg( _( "You can't see that destination." ) );
6924 continue;
6925 }
6926
6927 auto route = m.route( u.pos(), lp, u.get_pathfinding_settings(), u.get_path_avoid() );
6928 if( route.size() > 1 ) {
6929 route.pop_back();
6930 u.set_destination( route );
6931 } else {
6932 add_msg( m_info, _( "You can't travel there." ) );
6933 continue;
6934 }
6935 } else if( action == "debug_scent" || action == "debug_scent_type" ) {
6937 display_scent();
6938 }
6939 } else if( action == "debug_temp" ) {
6942 }
6943 } else if( action == "debug_lighting" ) {
6946 }
6947 } else if( action == "debug_transparency" ) {
6950 }
6951 } else if( action == "debug_radiation" ) {
6954 }
6955 } else if( action == "debug_submap_grid" ) {
6956 g->debug_submap_grid_overlay = !g->debug_submap_grid_overlay;
6957 } else if( action == "debug_hour_timer" ) {
6959 } else if( action == "EXTENDED_DESCRIPTION" ) {
6961 } else if( action == "CENTER" ) {
6962 center = u.pos();
6963 lp = u.pos();
6964 u.view_offset.z = 0;
6965 } else if( action == "MOUSE_MOVE" || action == "TIMEOUT" ) {
6966 // This block is structured this way so that edge scroll can work
6967 // whether the mouse is moving at the edge or simply stationary
6968 // at the edge. But even if edge scroll isn't in play, there's
6969 // other things for us to do here.
6970
6971 if( edge_scrolling ) {
6972 center += action == "MOUSE_MOVE" ? edge_scroll * 2 : edge_scroll;
6973 } else if( action == "MOUSE_MOVE" ) {
6974 const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
6975 if( mouse_pos ) {
6976 lx = mouse_pos->x;
6977 ly = mouse_pos->y;
6978 }
6979 }
6980 } else if( cata::optional<tripoint> vec = ctxt.get_direction( action ) ) {
6981 if( fast_scroll ) {
6982 vec->x *= soffset;
6983 vec->y *= soffset;
6984 }
6985
6986 lx = lx + vec->x;
6987 ly = ly + vec->y;
6988 center.x = center.x + vec->x;
6989 center.y = center.y + vec->y;
6990 } else if( action == "throw_blind" ) {
6991 result.peek_action = PA_BLIND_THROW;
6992 } else if( action == "zoom_in" ) {
6993 center.x = lp.x;
6994 center.y = lp.y;
6995 zoom_in();
6997 } else if( action == "zoom_out" ) {
6998 center.x = lp.x;
6999 center.y = lp.y;
7000 zoom_out();
7002 }
7003 } while( action != "QUIT" && action != "CONFIRM" && action != "SELECT" && action != "TRAVEL_TO" &&
7004 action != "throw_blind" );
7005
7006 if( m.has_zlevels() && center.z != old_levz ) {
7007 m.invalidate_map_cache( old_levz );
7008 m.build_map_cache( old_levz );
7009 u.view_offset.z = 0;
7010 }
7011
7012 ctxt.reset_timeout();
7013 u.view_offset = prev_offset;
7014 zone_cb = nullptr;
7015 is_looking = false;
7016
7018 bVMonsterLookFire = true;
7019
7020 if( action == "CONFIRM" || action == "SELECT" ) {
7021 result.position = is_moving_zone ? zone_start : lp;
7022 }
7023
7024#if defined(TILES)
7025 if( is_moving_zone && get_zoom() != prev_tileset_zoom ) {
7026 // Reset the tileset zoom to the previous value
7027 set_zoom( prev_tileset_zoom );
7029 }
7030#endif
7031
7032 return result;
7033}
bool pixel_minimap_option
Whether to show the pixel minimap.
tripoint mouse_edge_scrolling_terrain(input_context &ctxt)
Used to implement mouse "edge scrolling".
Definition: game.cpp:2188
void set_zoom(int level)
Definition: game.cpp:7190
void draw_look_around_cursor(const tripoint &lp, const visibility_variables &cache)
Definition: game.cpp:5796
void extended_description(const tripoint &p)
Long description of (visible) things at tile.
void pre_print_all_tile_info(const tripoint &lp, const catacurses::window &w_info, int &line, int last_line, const visibility_variables &cache)
Definition: game.cpp:6670
int get_zoom() const
Definition: game.cpp:7202
const visibility_variables & get_visibility_variables_cache() const
Definition: map.cpp:5645
void invalidate_map_cache(const int zlev)
Definition: map.h:475
std::vector< window_panel > & get_current_layout()
Definition: panels.cpp:2154
int square_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:505
static shared_ptr_fast< game::draw_callback_t > create_zone_callback(const cata::optional< tripoint > &zone_start, const cata::optional< tripoint > &zone_end, const bool &zone_blink, const bool &zone_cursor, const bool &is_moving_zone=false)
Definition: game.cpp:3184
@ PA_BLIND_THROW
Definition: game.h:122
static constexpr int OVERMAP_HEIGHT
static constexpr int BLINK_SPEED
static constexpr int OVERMAP_DEPTH
int right_print(const catacurses::window &w, const int line, const int right_indent, const nc_color &FG, const std::string &text)
Definition: output.cpp:461

References _, action, add_draw_callback(), add_msg(), BLINK_SPEED, map::build_map_cache(), bVMonsterLookFire, c_green, c_light_gray, c_light_green, c_white, center, center_print(), clamp(), create_zone_callback(), display_lighting(), display_radiation(), display_scent(), display_temperature(), display_transparency(), draw_border(), draw_look_around_cursor(), extended_description(), fov_3d_z_range, g, input_context::get_action_name(), input_context::get_coordinates(), panel_manager::get_current_layout(), input_context::get_desc(), input_context::get_direction(), get_levx(), get_levy(), get_levz(), panel_manager::get_manager(), Character::get_path_avoid(), Character::get_pathfinding_settings(), map::get_visibility_variables_cache(), panel_manager::get_width_left(), get_zoom(), catacurses::getmaxy(), input_context::handle_input(), map::has_zlevels(), invalidate_main_ui_adaptor(), map::invalidate_map_cache(), is_looking, MAP_SHARING::isCompetitive(), MAP_SHARING::isDebugger(), list_items_monsters(), m, m_debug, m_info, mark_main_ui_adaptor_resize(), mouse_edge_scrolling_terrain(), mvwprintz(), catacurses::newwin(), cata::nullopt, OVERMAP_DEPTH, OVERMAP_HEIGHT, PA_BLIND_THROW, pixel_minimap_option, Character::pos(), Character::posz(), pre_print_all_tile_info(), ui_manager::redraw(), reenter_fullscreen(), input_context::register_action(), input_context::register_directions(), input_context::reset_timeout(), right_print(), map::route(), Character::sees(), Character::set_destination(), input_context::set_iso(), input_context::set_timeout(), set_zoom(), square_dist(), string_format(), temp_exit_fullscreen(), TERMX, TERMY, tileset_zoom, toggle_debug_hour_timer(), toggle_pixel_minimap(), tripoint_zero, u, map::update_visibility_cache(), use_tiles, player::view_offset, w_pixel_minimap, w_terrain, catacurses::werase(), catacurses::wnoutrefresh(), tripoint::x, tripoint::y, tripoint::z, zoom_in(), and zoom_out().

◆ look_debug()

cata::optional< tripoint > game::look_debug ( )

Definition at line 5789 of file game.cpp.

5790{
5791 editmap edit;
5792 return edit.edit();
5793}
cata::optional< tripoint > edit()
Definition: editmap.cpp:339

References editmap::edit().

◆ mark_main_ui_adaptor_resize()

void game::mark_main_ui_adaptor_resize ( ) const

Definition at line 3141 of file game.cpp.

3142{
3144 if( ui ) {
3145 ui->mark_resize();
3146 }
3147}

References main_ui_adaptor.

Referenced by handle_action(), look_around(), toggle_fullscreen(), and toggle_pixel_minimap().

◆ memorial()

memorial_logger & game::memorial ( )

Definition at line 2883 of file game.cpp.

2884{
2885 return *memorial_logger_ptr;
2886}

References memorial_logger_ptr.

Referenced by cleanup_at_end(), load(), save_player_data(), win(), win_screen(), and write_memorial_file().

◆ mon_info()

void game::mon_info ( const catacurses::window w,
int  hor_padding = 0 
)

Definition at line 3832 of file game.cpp.

3833{
3834 const monster_visible_info &mon_visible = u.get_mon_visible();
3835 const auto &unique_types = mon_visible.unique_types;
3836 const auto &unique_mons = mon_visible.unique_mons;
3837 const auto &dangerous = mon_visible.dangerous;
3838
3839 const int width = getmaxx( w ) - 2 * hor_padding;
3840 const int maxheight = getmaxy( w );
3841
3842 const int startrow = 0;
3843
3844 // Print the direction headings
3845 // Reminder:
3846 // 7 0 1 unique_types uses these indices;
3847 // 6 8 2 0-7 are provide by direction_from()
3848 // 5 4 3 8 is used for local monsters (for when we explain them below)
3849
3850 const std::array<std::string, 8> dir_labels = {{
3851 _( "North:" ), _( "NE:" ), _( "East:" ), _( "SE:" ),
3852 _( "South:" ), _( "SW:" ), _( "West:" ), _( "NW:" )
3853 }
3854 };
3855 std::array<int, 8> widths;
3856 for( int i = 0; i < 8; i++ ) {
3857 widths[i] = utf8_width( dir_labels[i] );
3858 }
3859 std::array<int, 8> xcoords;
3860 const std::array<int, 8> ycoords = {{ 0, 0, 1, 2, 2, 2, 1, 0 }};
3861 xcoords[0] = xcoords[4] = width / 3;
3862 xcoords[1] = xcoords[3] = xcoords[2] = ( width / 3 ) * 2;
3863 xcoords[5] = xcoords[6] = xcoords[7] = 0;
3864 //for the alignment of the 1,2,3 rows on the right edge
3865 xcoords[2] -= utf8_width( _( "East:" ) ) - utf8_width( _( "NE:" ) );
3866 for( int i = 0; i < 8; i++ ) {
3867 nc_color c = unique_types[i].empty() && unique_mons[i].empty() ? c_dark_gray
3868 : ( dangerous[i] ? c_light_red : c_light_gray );
3869 mvwprintz( w, point( xcoords[i] + hor_padding, ycoords[i] + startrow ), c, dir_labels[i] );
3870 }
3871
3872 // Print the symbols of all monsters in all directions.
3873 for( int i = 0; i < 8; i++ ) {
3874 point pr( xcoords[i] + widths[i] + 1, ycoords[i] + startrow );
3875
3876 // The list of symbols needs a space on each end.
3877 int symroom = ( width / 3 ) - widths[i] - 2;
3878 const int typeshere_npc = unique_types[i].size();
3879 const int typeshere_mon = unique_mons[i].size();
3880 const int typeshere = typeshere_mon + typeshere_npc;
3881 for( int j = 0; j < typeshere && j < symroom; j++ ) {
3882 nc_color c;
3883 std::string sym;
3884 if( symroom < typeshere && j == symroom - 1 ) {
3885 // We've run out of room!
3886 c = c_white;
3887 sym = "+";
3888 } else if( j < typeshere_npc ) {
3889 switch( unique_types[i][j]->get_attitude() ) {
3890 case NPCATT_KILL:
3891 c = c_red;
3892 break;
3893 case NPCATT_FOLLOW:
3894 c = c_light_green;
3895 break;
3896 default:
3897 c = c_pink;
3898 break;
3899 }
3900 sym = "@";
3901 } else {
3902 const mtype &mt = *unique_mons[i][j - typeshere_npc].first;
3903 c = mt.color;
3904 sym = mt.sym;
3905 }
3906 mvwprintz( w, pr, c, sym );
3907
3908 pr.x++;
3909 }
3910 }
3911
3912 // Now we print their full names!
3913 struct nearest_loc_and_cnt {
3914 int nearest_loc;
3915 int cnt;
3916 };
3917 std::map<const mtype *, nearest_loc_and_cnt> all_mons;
3918 for( int loc = 0; loc < 9; loc++ ) {
3919 for( const std::pair<const mtype *, int> &mon : unique_mons[loc] ) {
3920 const auto mon_it = all_mons.find( mon.first );
3921 if( mon_it == all_mons.end() ) {
3922 all_mons.emplace( mon.first, nearest_loc_and_cnt{ loc, mon.second } );
3923 } else {
3924 // 8 being the nearest location (local monsters)
3925 mon_it->second.nearest_loc = std::max( mon_it->second.nearest_loc, loc );
3926 mon_it->second.cnt += mon.second;
3927 }
3928 }
3929 }
3930 std::vector<std::pair<const mtype *, int>> mons_at[9];
3931 for( const std::pair<const mtype *const, nearest_loc_and_cnt> &mon : all_mons ) {
3932 mons_at[mon.second.nearest_loc].emplace_back( mon.first, mon.second.cnt );
3933 }
3934
3935 // Start printing monster names on row 4. Rows 0-2 are for labels, and row 3
3936 // is blank.
3937 point pr( hor_padding, 4 + startrow );
3938
3939 // Print monster names, starting with those at location 8 (nearby).
3940 for( int j = 8; j >= 0 && pr.y < maxheight; j-- ) {
3941 // Separate names by some number of spaces (more for local monsters).
3942 int namesep = ( j == 8 ? 2 : 1 );
3943 for( const std::pair<const mtype *, int> &mon : mons_at[j] ) {
3944 const mtype *const type = mon.first;
3945 const int count = mon.second;
3946 if( pr.y >= maxheight ) {
3947 // no space to print to anyway
3948 break;
3949 }
3950
3951 const mtype &mt = *type;
3952 std::string name = mt.nname( count );
3953 // Some languages don't have plural forms, but we want to always
3954 // omit 1.
3955 if( count != 1 ) {
3956 name = string_format( pgettext( "monster count and name", "%1$d %2$s" ),
3957 count, name );
3958 }
3959
3960 // Move to the next row if necessary. (The +2 is for the "Z ").
3961 if( pr.x + 2 + utf8_width( name ) >= width ) {
3962 pr.y++;
3963 pr.x = hor_padding;
3964 }
3965
3966 if( pr.y < maxheight ) { // Don't print if we've overflowed
3967 mvwprintz( w, pr, mt.color, mt.sym );
3968 pr.x += 2; // symbol and space
3969 nc_color danger = c_dark_gray;
3970 if( mt.difficulty >= 30 ) {
3971 danger = c_red;
3972 } else if( mt.difficulty >= 16 ) {
3973 danger = c_light_red;
3974 } else if( mt.difficulty >= 8 ) {
3975 danger = c_white;
3976 } else if( mt.agro > 0 ) {
3977 danger = c_light_gray;
3978 }
3979 mvwprintz( w, pr, danger, name );
3980 pr.x += utf8_width( name ) + namesep;
3981 }
3982 }
3983 }
3984}
@ NPCATT_KILL
Definition: npc.h:91
@ NPCATT_FOLLOW
Definition: npc.h:84
std::vector< std::pair< const mtype *, int > > unique_mons[9]
Definition: avatar.h:47
bool dangerous[8]
Definition: avatar.h:50
std::vector< npc * > unique_types[9]
Definition: avatar.h:46
Definition: mtype.h:208
std::string sym
UTF-8 encoded symbol, should be exactly one cell wide.
Definition: mtype.h:256
nc_color color
Definition: mtype.h:261
int difficulty
Definition: mtype.h:267
int agro
e.g.
Definition: mtype.h:272

References _, mtype::agro, c, c_dark_gray, c_light_gray, c_light_green, c_light_red, c_pink, c_red, c_white, mtype::color, detail::count(), monster_visible_info::dangerous, mtype::difficulty, avatar::get_mon_visible(), catacurses::getmaxx(), catacurses::getmaxy(), mvwprintz(), om_direction::name(), mtype::nname(), NPCATT_FOLLOW, NPCATT_KILL, pgettext(), string_format(), mtype::sym, type, u, monster_visible_info::unique_mons, monster_visible_info::unique_types, utf8_width(), point::x, and point::y.

◆ mon_info_update()

void game::mon_info_update ( )

Definition at line 3986 of file game.cpp.

3987{
3988 int newseen = 0;
3989 const int safe_proxy_dist = get_option<int>( "SAFEMODEPROXIMITY" );
3990 const int iProxyDist = ( safe_proxy_dist <= 0 ) ? MAX_VIEW_DISTANCE :
3991 safe_proxy_dist;
3992
3993 monster_visible_info &mon_visible = u.get_mon_visible();
3994 auto &new_seen_mon = mon_visible.new_seen_mon;
3995 auto &unique_types = mon_visible.unique_types;
3996 auto &unique_mons = mon_visible.unique_mons;
3997 auto &dangerous = mon_visible.dangerous;
3998
3999 // 7 0 1 unique_types uses these indices;
4000 // 6 8 2 0-7 are provide by direction_from()
4001 // 5 4 3 8 is used for local monsters (for when we explain them below)
4002 for( auto &t : unique_types ) {
4003 t.clear();
4004 }
4005 for( auto &m : unique_mons ) {
4006 m.clear();
4007 }
4008 std::fill( dangerous, dangerous + 8, false );
4009
4010 const tripoint view = u.pos() + u.view_offset;
4011 new_seen_mon.clear();
4012
4013 // TODO: no reason to have it static here
4014 static time_point previous_turn = calendar::start_of_cataclysm;
4015 const time_duration sm_ignored_time = time_duration::from_turns(
4016 get_option<int>( "SAFEMODEIGNORETURNS" ) );
4017
4019 monster *m = dynamic_cast<monster *>( c );
4020 npc *p = dynamic_cast<npc *>( c );
4021 const direction dir_to_mon = direction_from( view.xy(), point( c->posx(), c->posy() ) );
4022 const int mx = POSX + ( c->posx() - view.x );
4023 const int my = POSY + ( c->posy() - view.y );
4024 int index = 8;
4025 if( !is_valid_in_w_terrain( point( mx, my ) ) ) {
4026 // for compatibility with old code, see diagram below, it explains the values for index,
4027 // also might need revisiting one z-levels are in.
4028 switch( dir_to_mon ) {
4032 index = 7;
4033 break;
4035 case direction::NORTH:
4037 index = 0;
4038 break;
4042 index = 1;
4043 break;
4045 case direction::WEST:
4047 index = 6;
4048 break;
4050 case direction::CENTER:
4052 index = 8;
4053 break;
4055 case direction::EAST:
4057 index = 2;
4058 break;
4062 index = 5;
4063 break;
4065 case direction::SOUTH:
4067 index = 4;
4068 break;
4072 index = 3;
4073 break;
4074 }
4075 }
4076
4077 rule_state safemode_state = RULE_NONE;
4078 const bool safemode_empty = get_safemode().empty();
4079
4080 if( m != nullptr ) {
4081 //Safemode monster check
4082 monster &critter = *m;
4083
4084 const monster_attitude matt = critter.attitude( &u );
4085 const int mon_dist = rl_dist( u.pos(), critter.pos() );
4086 safemode_state = get_safemode().check_monster( critter.name(), critter.attitude_to( u ), mon_dist );
4087
4088 if( ( !safemode_empty && safemode_state == RULE_BLACKLISTED ) || ( safemode_empty &&
4089 ( MATT_ATTACK == matt || MATT_FOLLOW == matt ) ) ) {
4090 if( index < 8 && critter.sees( g->u ) ) {
4091 dangerous[index] = true;
4092 }
4093
4094 if( !safemode_empty || mon_dist <= iProxyDist ) {
4095 bool passmon = false;
4096 if( critter.ignoring > 0 ) {
4097 if( safe_mode != SAFE_MODE_ON ) {
4098 critter.ignoring = 0;
4099 } else if( ( sm_ignored_time == 0_seconds || ( critter.lastseen_turn &&
4100 *critter.lastseen_turn > calendar::turn - sm_ignored_time ) ) &&
4101 ( mon_dist > critter.ignoring / 2 || mon_dist < 6 ) ) {
4102 passmon = true;
4103 }
4104 critter.lastseen_turn = calendar::turn;
4105 }
4106
4107 if( !passmon ) {
4108 newseen++;
4109 new_seen_mon.push_back( shared_from( critter ) );
4110 }
4111 }
4112 }
4113
4114 std::vector<std::pair<const mtype *, int>> &vec = unique_mons[index];
4115 const auto mon_it = std::find_if( vec.begin(), vec.end(),
4116 [&]( const std::pair<const mtype *, int> &elem ) {
4117 return elem.first == critter.type;
4118 } );
4119 if( mon_it == vec.end() ) {
4120 vec.emplace_back( critter.type, 1 );
4121 } else {
4122 mon_it->second++;
4123 }
4124 } else if( p != nullptr ) {
4125 //Safe mode NPC check
4126
4127 const int npc_dist = rl_dist( u.pos(), p->pos() );
4128 safemode_state = get_safemode().check_monster( get_safemode().npc_type_name(), p->attitude_to( u ),
4129 npc_dist );
4130
4131 if( ( !safemode_empty && safemode_state == RULE_BLACKLISTED ) || ( safemode_empty &&
4132 p->get_attitude() == NPCATT_KILL ) ) {
4133 if( !safemode_empty || npc_dist <= iProxyDist ) {
4134 newseen++;
4135 }
4136 }
4137 unique_types[index].push_back( p );
4138 }
4139 }
4140
4141 if( newseen > mostseen ) {
4142 if( newseen - mostseen == 1 ) {
4143 if( !new_seen_mon.empty() ) {
4144 monster &critter = *new_seen_mon.back();
4146 string_format( _( "%s spotted!" ), critter.name() ) );
4147 if( u.has_trait( trait_id( "M_DEFENDER" ) ) && critter.type->in_species( PLANT ) ) {
4148 add_msg( m_warning, _( "We have detected a %s - an enemy of the Mycus!" ), critter.name() );
4150 u.add_effect( effect_adrenaline_mycus, 30_minutes );
4151 } else if( u.get_effect_int( effect_adrenaline_mycus ) == 1 ) {
4152 // Triffids present. We ain't got TIME to adrenaline comedown!
4153 u.add_effect( effect_adrenaline_mycus, 15_minutes );
4154 u.mod_pain( 3 ); // Does take it out of you, though
4155 add_msg( m_info, _( "Our fibers strain with renewed wrath!" ) );
4156 }
4157 }
4158 } else {
4159 //Hostile NPC
4161 _( "Hostile survivor spotted!" ) );
4162 }
4163 } else {
4165 }
4167 if( safe_mode == SAFE_MODE_ON ) {
4169 }
4170 } else if( calendar::turn > previous_turn && get_option<bool>( "AUTOSAFEMODE" ) &&
4171 newseen == 0 ) { // Auto-safe mode, but only if it's a new turn
4172 turnssincelastmon += to_turns<int>( calendar::turn - previous_turn );
4173 if( turnssincelastmon >= get_option<int>( "AUTOSAFEMODETURNS" ) && safe_mode == SAFE_MODE_OFF ) {
4175 add_msg( m_info, _( "Safe mode ON!" ) );
4176 }
4177 }
4178
4179 if( newseen == 0 && safe_mode == SAFE_MODE_STOP ) {
4181 }
4182
4183 previous_turn = calendar::turn;
4184 mostseen = newseen;
4185}
int get_effect_int(const efftype_id &eff_id, body_part bp=num_bp) const
Returns the intensity of the matching effect.
Definition: creature.cpp:1250
virtual bool sees(const Creature &critter) const
The functions check whether this creature can see the target.
Definition: creature.cpp:202
bool cancel_activity_or_ignore_query(distraction_type type, const std::string &text)
Asks if the player wants to cancel their activity and if so cancels it.
Definition: game.cpp:1809
monster_attitude attitude(const Character *u=nullptr) const
Definition: monster.cpp:1086
cata::optional< time_point > lastseen_turn
Definition: monster.h:509
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
Definition: npc.cpp:2077
rule_state check_monster(const std::string &creature_name_in, Creature::Attitude attitude_in, int proximity_in) const
bool empty() const
rule_state
Definition: enums.h:51
@ RULE_NONE
Definition: enums.h:52
bool is_valid_in_w_terrain(const point &p)
Definition: game.cpp:278
static const species_id PLANT("PLANT")
static const efftype_id effect_adrenaline_mycus("adrenaline_mycus")
static constexpr int MAPSIZE_X
monster_attitude
Definition: monster.h:55
@ MATT_FOLLOW
Definition: monster.h:61
@ MATT_ATTACK
Definition: monster.h:62
FMT_NOINLINE OutputIt fill(OutputIt it, size_t n, const fill_t< Char > &fill)
bool in_species(const species_id &spec) const
Definition: mtype.cpp:122

References _, ABOVECENTER, ABOVEEAST, ABOVENORTH, ABOVENORTHEAST, ABOVENORTHWEST, ABOVESOUTH, ABOVESOUTHEAST, ABOVESOUTHWEST, ABOVEWEST, Creature::add_effect(), add_msg(), monster::attitude(), monster::attitude_to(), npc::attitude_to(), BELOWCENTER, BELOWEAST, BELOWNORTH, BELOWNORTHEAST, BELOWNORTHWEST, BELOWSOUTH, BELOWSOUTHEAST, BELOWSOUTHWEST, BELOWWEST, c, cancel_activity_or_ignore_query(), CENTER, safemode::check_monster(), monster_visible_info::dangerous, direction_from(), EAST, effect_adrenaline_mycus, safemode::empty(), detail::fill(), time_duration::from_turns(), g, npc::get_attitude(), Creature::get_effect_int(), avatar::get_mon_visible(), get_safemode(), Character::get_visible_creatures(), Creature::has_effect(), Character::has_trait(), hostile_spotted_far, monster::ignoring, mtype::in_species(), is_valid_in_w_terrain(), monster::lastseen_turn, m, m_info, m_warning, MAPSIZE_X, MATT_ATTACK, MATT_FOLLOW, MAX_VIEW_DISTANCE, player::mod_pain(), mostseen, monster::name(), monster_visible_info::new_seen_mon, NORTH, NORTHEAST, NORTHWEST, NPCATT_KILL, PLANT, Character::pos(), monster::pos(), POSX, POSY, rl_dist(), RULE_BLACKLISTED, RULE_NONE, safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAFE_MODE_STOP, Creature::sees(), set_safe_mode(), shared_from(), SOUTH, SOUTHEAST, SOUTHWEST, calendar::start_of_cataclysm, string_format(), calendar::turn, turnssincelastmon, monster::type, u, monster_visible_info::unique_mons, monster_visible_info::unique_types, player::view_offset, WEST, tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by do_turn().

◆ monmove()

void game::monmove ( )
private

Definition at line 4222 of file game.cpp.

4223{
4224 cleanup_dead();
4225
4226 for( monster &critter : all_monsters() ) {
4227 // Critters in impassable tiles get pushed away, unless it's not impassable for them
4228 if( !critter.is_dead() && m.impassable( critter.pos() ) && !critter.can_move_to( critter.pos() ) ) {
4229 std::string msg = string_format( "%s can't move to its location! %s %s", critter.name(),
4230 critter.pos().to_string(), m.tername( critter.pos() ) );
4231 dbg( DL::Error ) << msg;
4232 add_msg( m_debug, msg );
4233 bool okay = false;
4234 for( const tripoint &dest : m.points_in_radius( critter.pos(), 3 ) ) {
4235 if( critter.can_move_to( dest ) && is_empty( dest ) ) {
4236 critter.setpos( dest );
4237 okay = true;
4238 break;
4239 }
4240 }
4241 if( !okay ) {
4242 // die of "natural" cause (overpopulation is natural)
4243 critter.die( nullptr );
4244 }
4245 }
4246
4247 if( !critter.is_dead() ) {
4248 critter.process_items();
4249 }
4250
4251 if( !critter.is_dead() ) {
4252 critter.process_turn();
4253 }
4254
4255 m.creature_in_field( critter );
4256 if( calendar::once_every( 1_days ) ) {
4257 if( critter.has_flag( MF_MILKABLE ) ) {
4258 critter.refill_udders();
4259 }
4260 critter.try_reproduce();
4261 }
4262 while( critter.moves > 0 && !critter.is_dead() && !critter.has_effect( effect_ridden ) ) {
4263 critter.made_footstep = false;
4264 // Controlled critters don't make their own plans
4265 if( !critter.has_effect( effect_ai_controlled ) ) {
4266 // Formulate a path to follow
4267 critter.plan();
4268 }
4269 critter.move(); // Move one square, possibly hit u
4270 critter.process_triggers();
4271 m.creature_in_field( critter );
4272 }
4273
4274 if( !critter.is_dead() &&
4275 u.has_active_bionic( bionic_id( "bio_alarm" ) ) &&
4276 u.get_power_level() >= 25_kJ &&
4277 rl_dist( u.pos(), critter.pos() ) <= 5 &&
4278 !critter.is_hallucination() ) {
4279 u.mod_power_level( -25_kJ );
4280 add_msg( m_warning, _( "Your motion alarm goes off!" ) );
4282 _( "Your motion alarm goes off!" ) );
4283 if( u.has_effect( efftype_id( "sleep" ) ) ) {
4284 u.wake_up();
4285 }
4286 }
4287 }
4288
4289 cleanup_dead();
4290
4291 // The remaining monsters are all alive, but may be outside of the reality bubble.
4292 // If so, despawn them. This is not the same as dying, they will be stored for later and the
4293 // monster::die function is not called.
4294 for( monster &critter : all_monsters() ) {
4295 if( critter.posx() < 0 - ( MAPSIZE_X ) / 6 ||
4296 critter.posy() < 0 - ( MAPSIZE_Y ) / 6 ||
4297 critter.posx() > ( MAPSIZE_X * 7 ) / 6 ||
4298 critter.posy() > ( MAPSIZE_Y * 7 ) / 6 ) {
4299 despawn_monster( critter );
4300 }
4301 }
4302
4303 // Now, do active NPCs.
4304 for( npc &guy : g->all_npcs() ) {
4305 int turns = 0;
4306 if( guy.is_mounted() ) {
4307 guy.check_mount_is_spooked();
4308 }
4309 m.creature_in_field( guy );
4310 if( !guy.has_effect( effect_npc_suspend ) ) {
4311 guy.process_turn();
4312 }
4313 while( !guy.is_dead() && guy.moves > 0 && turns < 10 &&
4314 ( !guy.in_sleep_state() || guy.activity.id() == ACT_OPERATION )
4315 ) {
4316 int moves = guy.moves;
4317 guy.move();
4318 if( moves == guy.moves ) {
4319 // Count every time we exit npc::move() without spending any moves.
4320 turns++;
4321 }
4322
4323 // Turn on debug mode when in infinite loop
4324 // It has to be done before the last turn, otherwise
4325 // there will be no meaningful debug output.
4326 if( turns == 9 ) {
4327 debugmsg( "NPC %s entered infinite loop. Turning on debug mode",
4328 guy.name );
4329 debug_mode = true;
4330 }
4331 }
4332
4333 // If we spun too long trying to decide what to do (without spending moves),
4334 // Invoke cognitive suspension to prevent an infinite loop.
4335 if( turns == 10 ) {
4336 add_msg( _( "%s faints!" ), guy.name );
4337 guy.reboot();
4338 }
4339
4340 if( !guy.is_dead() ) {
4341 guy.npc_update_body();
4342 }
4343 }
4344 cleanup_dead();
4345}
void mod_power_level(const units::energy &npower)
Definition: character.cpp:1987
units::energy get_power_level() const
Definition: character.cpp:1967
void wake_up()
Definition: avatar.cpp:947
static const activity_id ACT_OPERATION("ACT_OPERATION")
static const efftype_id effect_npc_suspend("npc_suspend")
static const efftype_id effect_ai_controlled("ai_controlled")
static constexpr int MAPSIZE_Y
@ MF_MILKABLE
Definition: mtype.h:167

References _, ACT_OPERATION, add_msg(), alert, all_monsters(), cancel_activity_or_ignore_query(), cleanup_dead(), map::creature_in_field(), dbg, debug_mode, debugmsg, despawn_monster(), effect_ai_controlled, effect_npc_suspend, effect_ridden, Error, g, Character::get_power_level(), Character::has_active_bionic(), Creature::has_effect(), map::impassable(), is_empty(), m, m_debug, m_warning, MAPSIZE_X, MAPSIZE_Y, MF_MILKABLE, Character::mod_power_level(), calendar::once_every(), map::points_in_radius(), Character::pos(), rl_dist(), string_format(), map::tername(), u, and avatar::wake_up().

Referenced by do_turn().

◆ mouse_edge_scrolling()

std::pair< tripoint, tripoint > game::mouse_edge_scrolling ( input_context ctxt,
int  speed,
const tripoint last,
bool  iso 
)
private

Definition at line 2135 of file game.cpp.

2137{
2138 const int rate = get_option<int>( "EDGE_SCROLL" );
2139 auto ret = std::make_pair( tripoint_zero, last );
2140 if( rate == -1 ) {
2141 // Fast return when the option is disabled.
2142 return ret;
2143 }
2144 // Ensure the parameters are used even if the #if below is false
2145 ( void ) ctxt;
2146 ( void ) speed;
2147 ( void ) iso;
2148#if (defined TILES || defined _WIN32 || defined WINDOWS)
2149 auto now = std::chrono::steady_clock::now();
2150 if( now < last_mouse_edge_scroll + std::chrono::milliseconds( rate ) ) {
2151 return ret;
2152 } else {
2154 }
2155 const input_event event = ctxt.get_raw_input();
2156 if( event.type == CATA_INPUT_MOUSE ) {
2157 const point threshold( projected_window_width() / 100, projected_window_height() / 100 );
2158 if( event.mouse_pos.x <= threshold.x ) {
2159 ret.first.x -= speed;
2160 if( iso ) {
2161 ret.first.y -= speed;
2162 }
2163 } else if( event.mouse_pos.x >= projected_window_width() - threshold.x ) {
2164 ret.first.x += speed;
2165 if( iso ) {
2166 ret.first.y += speed;
2167 }
2168 }
2169 if( event.mouse_pos.y <= threshold.y ) {
2170 ret.first.y -= speed;
2171 if( iso ) {
2172 ret.first.x += speed;
2173 }
2174 } else if( event.mouse_pos.y >= projected_window_height() - threshold.y ) {
2175 ret.first.y += speed;
2176 if( iso ) {
2177 ret.first.x -= speed;
2178 }
2179 }
2180 ret.second = ret.first;
2181 } else if( event.type == CATA_INPUT_TIMEOUT ) {
2182 ret.first = ret.second;
2183 }
2184#endif
2185 return ret;
2186}
@ CATA_INPUT_TIMEOUT
Definition: input.h:81
@ CATA_INPUT_MOUSE
Definition: input.h:84

References CATA_INPUT_MOUSE, CATA_INPUT_TIMEOUT, input_context::get_raw_input(), iso, last, last_mouse_edge_scroll, cata::hash64_detail::ret, tripoint_zero, point::x, and point::y.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ mouse_edge_scrolling_overmap()

tripoint game::mouse_edge_scrolling_overmap ( input_context ctxt)

This variant is suitable for the overmap.

Definition at line 2197 of file game.cpp.

2198{
2199 // overmap has no iso mode
2203 return ret.first;
2204}
std::pair< tripoint, tripoint > mouse_edge_scrolling(input_context &ctxt, int speed, const tripoint &last, bool iso)
Definition: game.cpp:2135
tripoint last_mouse_edge_scroll_vector_terrain
Definition: game.h:1095
tripoint last_mouse_edge_scroll_vector_overmap
Definition: game.h:1096

References last_mouse_edge_scroll_vector_overmap, last_mouse_edge_scroll_vector_terrain, mouse_edge_scrolling(), cata::hash64_detail::ret, and tripoint_zero.

◆ mouse_edge_scrolling_terrain()

tripoint game::mouse_edge_scrolling_terrain ( input_context ctxt)

Used to implement mouse "edge scrolling".

Returns a tripoint which is a vector of the resulting "move", i.e. (0, 0, 0) if the mouse is not at the edge of the screen, otherwise some (x, y, 0) depending on which edges are hit. This variant adjust scrolling speed according to zoom level, making it suitable when viewing the "terrain".

Definition at line 2188 of file game.cpp.

References DEFAULT_TILESET_ZOOM, last_mouse_edge_scroll_vector_overmap, last_mouse_edge_scroll_vector_terrain, mouse_edge_scrolling(), cata::hash64_detail::ret, tile_iso, tileset_zoom, and tripoint_zero.

Referenced by look_around().

◆ move_save_to_graveyard()

void game::move_save_to_graveyard ( const std::string &  dirname)
private

Definition at line 2570 of file game.cpp.

2571{
2572 const std::string save_dir = get_world_base_save_path();
2573 const std::string graveyard_dir = PATH_INFO::graveyarddir() + "/";
2574 const std::string graveyard_save_dir = graveyard_dir + dirname + "/";
2575 const std::string prefix = base64_encode( u.name ) + ".";
2576
2577 if( !assure_dir_exist( graveyard_dir ) ) {
2578 debugmsg( "could not create graveyard path '%s'", graveyard_dir );
2579 }
2580
2581 if( !assure_dir_exist( graveyard_save_dir ) ) {
2582 debugmsg( "could not create graveyard path '%s'", graveyard_save_dir );
2583 }
2584
2585 const auto save_files = get_files_from_path( prefix, save_dir );
2586 if( save_files.empty() ) {
2587 debugmsg( "could not find save files in '%s'", save_dir );
2588 }
2589
2590 for( const auto &src_path : save_files ) {
2591 const std::string dst_path = graveyard_save_dir +
2592 src_path.substr( src_path.rfind( '/' ), std::string::npos );
2593
2594 if( rename_file( src_path, dst_path ) ) {
2595 continue;
2596 }
2597
2598 debugmsg( "could not rename file '%s' to '%s'", src_path, dst_path );
2599
2600 if( remove_file( src_path ) ) {
2601 continue;
2602 }
2603
2604 debugmsg( "could not remove file '%s'", src_path );
2605 }
2606}
@ prefix
Definition: enums.h:79
bool remove_file(const std::string &path)
Remove a file.
Definition: filesystem.cpp:89
bool assure_dir_exist(const std::string &path)
Create directory if it does not exist.
Definition: filesystem.cpp:48
bool rename_file(const std::string &old_path, const std::string &new_path)
Rename a file, overwriting the target.
Definition: filesystem.cpp:105
std::vector< std::string > get_files_from_path(const std::string &pattern, const std::string &root_path, const bool recursive_search, const bool match_extension)
Returns a vector of files or directories matching pattern at root_path.
Definition: filesystem.cpp:362
std::string graveyarddir()
Definition: path_info.cpp:202

References assure_dir_exist(), base64_encode(), debugmsg, get_files_from_path(), get_world_base_save_path(), PATH_INFO::graveyarddir(), Character::name, prefix, remove_file(), rename_file(), and u.

Referenced by cleanup_at_end().

◆ moving_vehicle_dismount()

void game::moving_vehicle_dismount ( const tripoint dest_loc)

Handles players exiting from moving vehicles.

Definition at line 5257 of file game.cpp.

5258{
5259 const optional_vpart_position vp = m.veh_at( u.pos() );
5260 if( !vp ) {
5261 debugmsg( "Tried to exit non-existent vehicle." );
5262 return;
5263 }
5264 vehicle *const veh = &vp->vehicle();
5265 if( u.pos() == dest_loc ) {
5266 debugmsg( "Need somewhere to dismount towards." );
5267 return;
5268 }
5269 tileray ray( dest_loc.xy() + point( -u.posx(), -u.posy() ) );
5270 // TODO:: make dir() const correct!
5271 const units::angle d = ray.dir();
5272 add_msg( _( "You dive from the %s." ), veh->name );
5273 m.unboard_vehicle( u.pos() );
5274 u.moves -= 200;
5275 // Dive three tiles in the direction of tox and toy
5276 fling_creature( &u, d, 30, true );
5277 // Hit the ground according to vehicle speed
5278 if( !m.has_flag( "SWIMMABLE", u.pos() ) ) {
5279 if( veh->velocity > 0 ) {
5280 fling_creature( &u, veh->face.dir(), veh->velocity / static_cast<float>( 100 ) );
5281 } else {
5282 fling_creature( &u, veh->face.dir() + 180_degrees,
5283 -( veh->velocity ) / static_cast<float>( 100 ) );
5284 }
5285 }
5286}
void fling_creature(Creature *c, const units::angle &dir, float flvel, bool controlled=false, bool suppress_map_update=false)
Flings the input creature in the given direction.
Definition: game.cpp:9862

References _, add_msg(), debugmsg, tileray::dir(), vehicle::face, fling_creature(), map::has_flag(), m, Creature::moves, vehicle::name, Character::pos(), Character::posx(), Character::posy(), u, map::unboard_vehicle(), map::veh_at(), vehicle::velocity, and tripoint::xy().

◆ natural_light_level()

float game::natural_light_level ( int  zlev) const

Definition at line 3651 of file game.cpp.

3652{
3653 // ignore while underground or above limits
3654 if( zlev > OVERMAP_HEIGHT || zlev < 0 ) {
3655 return LIGHT_AMBIENT_MINIMAL;
3656 }
3657
3658 if( latest_lightlevels[zlev] > -std::numeric_limits<float>::max() ) {
3659 // Already found the light level for now?
3660 return latest_lightlevels[zlev];
3661 }
3662
3663 float ret = LIGHT_AMBIENT_MINIMAL;
3664
3665 // Sunlight/moonlight related stuff
3667 if( !weather.lightning_active ) {
3669 } else {
3670 // Recent lightning strike has lit the area
3672 }
3673
3675
3676 // Artifact light level changes here. Even though some of these only have an effect
3677 // aboveground it is cheaper performance wise to simply iterate through the entire
3678 // list once instead of twice.
3679 float mod_ret = -1;
3680 // Each artifact change does std::max(mod_ret, new val) since a brighter end value
3681 // will trump a lower one.
3682 if( const timed_event *e = timed_events.get( TIMED_EVENT_DIM ) ) {
3683 // TIMED_EVENT_DIM slowly dims the natural sky level, then relights it.
3684 const time_duration left = e->when - calendar::turn;
3685 // TIMED_EVENT_DIM has an occurrence date of turn + 50, so the first 25 dim it,
3686 if( left > 25_turns ) {
3687 mod_ret = std::max( static_cast<double>( mod_ret ), ( ret * ( left - 25_turns ) ) / 25_turns );
3688 // and the last 25 scale back towards normal.
3689 } else {
3690 mod_ret = std::max( static_cast<double>( mod_ret ), ( ret * ( 25_turns - left ) ) / 25_turns );
3691 }
3692 }
3694 // TIMED_EVENT_ARTIFACT_LIGHT causes everywhere to become as bright as day.
3695 mod_ret = std::max<float>( ret, default_daylight_level() );
3696 }
3697 // If we had a changed light level due to an artifact event then it overwrites
3698 // the natural light level.
3699 if( mod_ret > -1 ) {
3700 ret = mod_ret;
3701 }
3702
3703 // Cap everything to our minimum light level
3704 ret = std::max<float>( LIGHT_AMBIENT_MINIMAL, ret );
3705
3706 latest_lightlevels[zlev] = ret;
3707
3708 return ret;
3709}
double default_daylight_level()
How much light is provided in full daylight.
Definition: calendar.cpp:62
float sunlight(const time_point &p, const bool vision)
Returns the current sunlight or moonlight level through the preceding functions.
Definition: calendar.cpp:199
std::array< float, OVERMAP_LAYERS > latest_lightlevels
Definition: game.h:1068
bool queued(timed_event_type type) const
timed_event * get(timed_event_type type)
weather_type_id weather_id
Definition: weather.h:193
static constexpr float LIGHT_AMBIENT_MINIMAL
Definition: lightmap.h:12
@ TIMED_EVENT_DIM
Definition: timed_event.h:22
@ TIMED_EVENT_ARTIFACT_LIGHT
Definition: timed_event.h:23

References default_daylight_level(), timed_event_manager::get(), get_weather, latest_lightlevels, left, LIGHT_AMBIENT_MINIMAL, weather_type::light_modifier, OVERMAP_HEIGHT, timed_event_manager::queued(), cata::hash64_detail::ret, sunlight(), TIMED_EVENT_ARTIFACT_LIGHT, TIMED_EVENT_DIM, timed_events, calendar::turn, and weather_manager::weather_id.

Referenced by light_level().

◆ npc_menu()

bool game::npc_menu ( npc who)

Returns true if the menu handled stuff and player shouldn't do anything else.

Perception slightly increases precision when examining NPCs' wounds Firstaid increases precision when examining NPCs' wounds

Definition at line 5388 of file game.cpp.

5389{
5390 enum choices : int {
5391 talk = 0,
5392 swap_pos,
5393 push,
5394 examine_wounds,
5395 use_item,
5396 sort_armor,
5397 attack,
5398 disarm,
5399 steal
5400 };
5401
5402 const bool obeys = debug_mode || ( who.is_player_ally() && !who.in_sleep_state() );
5403
5404 uilist amenu;
5405
5406 amenu.text = string_format( _( "What to do with %s?" ), who.disp_name() );
5407 amenu.addentry( talk, true, 't', _( "Talk" ) );
5408 amenu.addentry( swap_pos, obeys && !who.is_mounted() &&
5409 !u.is_mounted(), 's', _( "Swap positions" ) );
5410 amenu.addentry( push, obeys && !who.is_mounted(), 'p', _( "Push away" ) );
5411 amenu.addentry( examine_wounds, true, 'w', _( "Examine wounds" ) );
5412 amenu.addentry( use_item, true, 'i', _( "Use item on" ) );
5413 amenu.addentry( sort_armor, true, 'r', _( "Sort armor" ) );
5414 amenu.addentry( attack, true, 'a', _( "Attack" ) );
5415 if( !who.is_player_ally() ) {
5416 amenu.addentry( disarm, who.is_armed(), 'd', _( "Disarm" ) );
5417 amenu.addentry( steal, !who.is_enemy(), 'S', _( "Steal" ) );
5418 }
5419
5420 amenu.query();
5421
5422 const int choice = amenu.ret;
5423 if( choice == talk ) {
5424 who.talk_to_u();
5425 } else if( choice == swap_pos ) {
5426 if( !prompt_dangerous_tile( who.pos() ) ) {
5427 return true;
5428 }
5429 // TODO: Make NPCs protest when displaced onto dangerous crap
5430 add_msg( _( "You swap places with %s." ), who.name );
5431 swap_critters( u, who );
5432 // TODO: Make that depend on stuff
5433 u.mod_moves( -200 );
5434 } else if( choice == push ) {
5435 // TODO: Make NPCs protest when displaced onto dangerous crap
5436 tripoint oldpos = who.pos();
5437 who.move_away_from( u.pos(), true );
5438 u.mod_moves( -20 );
5439 if( oldpos != who.pos() ) {
5440 add_msg( _( "%s moves out of the way." ), who.name );
5441 } else {
5442 add_msg( m_warning, _( "%s has nowhere to go!" ), who.name );
5443 }
5444 } else if( choice == examine_wounds ) {
5445 ///\EFFECT_PER slightly increases precision when examining NPCs' wounds
5446
5447 ///\EFFECT_FIRSTAID increases precision when examining NPCs' wounds
5448 const bool precise = u.get_skill_level( skill_firstaid ) * 4 + u.per_cur >= 20;
5449 who.body_window( _( "Limbs of: " ) + who.disp_name(), true, precise, 0, 0, 0, 0.0f, 0.0f, 0.0f,
5450 0.0f, 0.0f );
5451 } else if( choice == use_item ) {
5452 static const std::string heal_string( "heal" );
5453 const auto will_accept = []( const item & it ) {
5454 const auto use_fun = it.get_use( heal_string );
5455 if( use_fun == nullptr ) {
5456 return false;
5457 }
5458
5459 const auto *actor = dynamic_cast<const heal_actor *>( use_fun->get_actor_ptr() );
5460
5461 return actor != nullptr &&
5462 actor->limb_power >= 0 &&
5463 actor->head_power >= 0 &&
5464 actor->torso_power >= 0;
5465 };
5466 item_location loc = game_menus::inv::titled_filter_menu( will_accept, u, _( "Use which item?" ) );
5467
5468 if( !loc ) {
5469 add_msg( _( "Never mind" ) );
5470 return false;
5471 }
5472 item &used = *loc;
5473 bool did_use = u.invoke_item( &used, heal_string, who.pos() );
5474 if( did_use ) {
5475 // Note: exiting a body part selection menu counts as use here
5476 u.mod_moves( -300 );
5477 }
5478 } else if( choice == sort_armor ) {
5479 who.sort_armor();
5480 u.mod_moves( -100 );
5481 } else if( choice == attack ) {
5482 if( who.is_enemy() || query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5483 u.melee_attack( who, true );
5484 who.on_attacked( u );
5485 }
5486 } else if( choice == disarm ) {
5487 if( who.is_enemy() || query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5488 u.disarm( who );
5489 }
5490 } else if( choice == steal && query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5491 u.steal( who );
5492 }
5493
5494 return true;
5495}
hp_part body_window(const std::string &menu_header, bool show_all, bool precise, int normal_bonus, int head_bonus, int torso_bonus, float bleed, float bite, float infect, float bandage_power, float disinfectant_power) const
Displays menu with body part hp, optionally with hp estimation after healing.
Definition: character.cpp:5848
bool in_sleep_state() const override
Definition: character.cpp:9325
void melee_attack(Creature &t, bool allow_special, const matec_id &force_technique, bool allow_unarmed=true)
Sets up a melee attack and handles melee attack function calls.
Definition: melee.cpp:390
int per_cur
Definition: character.h:250
void steal(npc &target)
Try to steal an item from the NPC's inventory.
Definition: melee.cpp:2391
bool prompt_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:8802
bool swap_critters(Creature &, Creature &)
Swaps positions of two creatures.
Definition: game.cpp:4903
float limb_power
How much hp to restore when healing limbs?
Definition: iuse_actor.h:1011
void talk_to_u(bool radio_contact=false)
Definition: npctalk.cpp:731
void on_attacked(const Creature &attacker)
Definition: npc.cpp:1449
void move_away_from(const tripoint &p, bool no_bash_atk=false, std::set< tripoint > *nomove=nullptr)
Definition: npcmove.cpp:2535
void disarm(npc &target)
Try to disarm the NPC.
Definition: melee.cpp:2315
static const skill_id skill_firstaid("firstaid")
static void swap_pos(Creature &caster, const tripoint &target)
item_location steal(avatar &you, player &victim)
Menu for stealing stuff.
item_location titled_filter_menu(item_filter filter, avatar &you, const std::string &title, const std::string &none_message="")
void push(monster &z)
Definition: monexamine.cpp:604

References _, add_msg(), uilist::addentry(), Character::body_window(), debug_mode, player::disarm(), Character::disp_name(), Character::get_skill_level(), Character::in_sleep_state(), avatar::invoke_item(), Character::is_armed(), npc::is_enemy(), Character::is_mounted(), npc::is_player_ally(), heal_actor::limb_power, m_warning, Character::melee_attack(), Creature::mod_moves(), npc::move_away_from(), Character::name, npc::on_attacked(), Character::per_cur, Character::pos(), prompt_dangerous_tile(), monexamine::push(), uilist::query(), query_yn(), uilist::ret, skill_firstaid, player::sort_armor(), game_menus::inv::steal(), avatar::steal(), string_format(), swap_critters(), swap_pos(), npc::talk_to_u(), uilist::text, game_menus::inv::titled_filter_menu(), u, and avatar_action::use_item().

Referenced by examine().

◆ num_creatures()

size_t game::num_creatures ( ) const

Returns the approximate number of creatures in the reality bubble.

Because of performance restrictions it may return a slightly incorrect values (as it includes dead, but not yet cleaned up creatures).

Definition at line 4848 of file game.cpp.

4849{
4850 return critter_tracker->size() + active_npc.size() + 1; // 1 == g->u
4851}

References active_npc, and critter_tracker.

Referenced by display_visibility(), and fungal_effects::fungalize().

◆ on_move_effects()

void game::on_move_effects ( )

Definition at line 9820 of file game.cpp.

9821{
9822 // TODO: Move this to a character method
9823 if( !u.is_mounted() ) {
9824 const item muscle( "muscle" );
9825 for( const bionic_id &bid : u.get_bionic_fueled_with( muscle ) ) {
9826 if( u.has_active_bionic( bid ) ) {// active power gen
9827 u.mod_power_level( units::from_kilojoule( muscle.fuel_energy() ) * bid->fuel_efficiency );
9828 } else if( u.has_bionic( bid ) ) {// passive power gen
9829 u.mod_power_level( units::from_kilojoule( muscle.fuel_energy() ) * bid->passive_fuel_efficiency );
9830 }
9831 }
9832
9833 if( u.has_active_bionic( bionic_id( "bio_jointservo" ) ) ) {
9834 if( u.movement_mode_is( CMM_RUN ) ) {
9835 u.mod_power_level( -55_J );
9836 } else {
9837 u.mod_power_level( -35_J );
9838 }
9839 }
9840 }
9841
9842 if( u.movement_mode_is( CMM_RUN ) ) {
9843 if( !u.can_run() ) {
9845 }
9846 }
9847
9848 // apply martial art move bonuses
9849 u.martial_arts_data->ma_onmove_effects( u );
9850
9852}
@ CMM_RUN
Definition: character.h:103
bool can_run()
source of truth of whether a Character can run
Definition: character.cpp:1329
bool movement_mode_is(character_movemode mode) const
Check against the character's current movement mode.
Definition: character.cpp:1619
std::vector< bionic_id > get_bionic_fueled_with(const item &it) const
Return bionic_id of bionics able to use it as fuel.
Definition: character.cpp:1928
bool has_bionic(const bionic_id &b) const
Returns true if the player has the entered bionic id.
Definition: character.cpp:1877
void do_ambient()
Definition: sounds.cpp:1616
constexpr quantity< value_type, energy_in_joule_tag > from_kilojoule(const value_type v)
Definition: units_energy.h:32

References Character::can_run(), CMM_RUN, sfx::do_ambient(), units::from_kilojoule(), item::fuel_energy(), Character::get_bionic_fueled_with(), Character::has_active_bionic(), Character::has_bionic(), Character::is_mounted(), Character::martial_arts_data, Character::mod_power_level(), Character::movement_mode_is(), avatar::toggle_run_mode(), and u.

Referenced by phasing_move(), and walk_move().

◆ on_options_changed()

void game::on_options_changed ( )

Should be invoked whenever options change.

Definition at line 9854 of file game.cpp.

9855{
9856#if defined(TILES)
9857 tilecontext->on_options_changed();
9858#endif
9859 grid_tracker_ptr->on_options_changed();
9860}

References grid_tracker_ptr.

◆ open_consume_item_menu()

void game::open_consume_item_menu ( )
private

Definition at line 1489 of file handle_action.cpp.

1490{
1491 uilist as_m;
1492
1493 as_m.text = _( "What do you want to consume?" );
1494
1495 as_m.entries.emplace_back( 0, true, 'f', _( "Food" ) );
1496 as_m.entries.emplace_back( 1, true, 'd', _( "Drink" ) );
1497 as_m.entries.emplace_back( 2, true, 'm', _( "Medication" ) );
1498 as_m.query();
1499
1500 switch( as_m.ret ) {
1501 case 0:
1503 break;
1504 case 1:
1506 break;
1507 case 2:
1509 break;
1510 default:
1511 break;
1512 }
1513}
std::vector< uilist_entry > entries
Definition: ui.h:323
item_location consume_drink(player &p)
Consuming a drink item via a custom menu.
item_location consume_meds(player &p)
Consuming a medication item via a custom menu.
item_location consume_food(player &p)
Consuming a food item via a custom menu.

References _, game_menus::inv::consume_drink(), game_menus::inv::consume_food(), game_menus::inv::consume_meds(), avatar_action::eat(), uilist::entries, uilist::query(), uilist::ret, uilist::text, and u.

Referenced by handle_action().

◆ overmap_npc_move()

void game::overmap_npc_move ( )
private

Definition at line 4347 of file game.cpp.

4348{
4349 std::vector<npc *> travelling_npcs;
4350 static constexpr int move_search_radius = 600;
4351 for( auto &elem : overmap_buffer.get_npcs_near_player( move_search_radius ) ) {
4352 if( !elem ) {
4353 continue;
4354 }
4355 npc *npc_to_add = elem.get();
4356 if( ( !npc_to_add->is_active() || rl_dist( u.pos(), npc_to_add->pos() ) > SEEX * 2 ) &&
4357 npc_to_add->mission == NPC_MISSION_TRAVELLING ) {
4358 travelling_npcs.push_back( npc_to_add );
4359 }
4360 }
4361 for( auto &elem : travelling_npcs ) {
4362 if( elem->has_omt_destination() ) {
4363 if( !elem->omt_path.empty() && rl_dist( elem->omt_path.back(), elem->global_omt_location() ) > 2 ) {
4364 //recalculate path, we got distracted doing something else probably
4365 elem->omt_path.clear();
4366 }
4367 if( elem->omt_path.empty() ) {
4368 const tripoint_abs_omt &from = elem->global_omt_location();
4369 const tripoint_abs_omt &to = elem->goal;
4370 elem->omt_path = overmap_buffer.get_travel_path( elem->global_omt_location(), elem->goal,
4372 if( elem->omt_path.empty() ) {
4373 add_msg( m_debug, "%s couldn't find overmap path from %s to %s",
4374 elem->get_name(), from.to_string(), to.to_string() );
4375 elem->goal = npc::no_goal_point;
4376 elem->mission = NPC_MISSION_NULL;
4377 }
4378 } else {
4379 if( elem->omt_path.back() == elem->global_omt_location() ) {
4380 elem->omt_path.pop_back();
4381 }
4382 // TODO: fix point types
4383 elem->travel_overmap(
4384 project_to<coords::sm>( elem->omt_path.back() ).raw() );
4385 }
4386 reload_npcs();
4387 }
4388 }
4389 return;
4390}
std::vector< tripoint_abs_omt > omt_path
Definition: character.h:970
static constexpr tripoint_abs_omt no_goal_point
Definition: npc.h:1338
bool is_active() const
Definition: npc.cpp:2195
std::vector< tripoint_abs_omt > get_travel_path(const tripoint_abs_omt &src, const tripoint_abs_omt &dest, overmap_path_params params)
@ NPC_MISSION_NULL
Definition: npc.h:179
@ NPC_MISSION_TRAVELLING
Definition: npc.h:191
static overmap_path_params for_npc()

References add_msg(), overmap_path_params::for_npc(), overmapbuffer::get_npcs_near_player(), overmapbuffer::get_travel_path(), npc::is_active(), m_debug, npc::mission, npc::no_goal_point, NPC_MISSION_NULL, NPC_MISSION_TRAVELLING, Character::omt_path, overmap_buffer, Character::pos(), reload_npcs(), rl_dist(), SEEX, coords::coord_point< Point, Origin, Scale >::to_string(), and u.

Referenced by do_turn().

◆ peek() [1/2]

void game::peek ( )

Definition at line 5747 of file game.cpp.

5748{
5749 const cata::optional<tripoint> p = choose_direction( _( "Peek where?" ), true );
5750 if( !p ) {
5751 return;
5752 }
5753
5754 if( p->z != 0 ) {
5755 const tripoint old_pos = u.pos();
5756 vertical_move( p->z, false, true );
5757
5758 if( old_pos != u.pos() ) {
5759 look_around();
5760 vertical_move( p->z * -1, false, true );
5761 }
5762 return;
5763 }
5764
5765 if( m.impassable( u.pos() + *p ) || m.obstructed_by_vehicle_rotation( u.pos(), u.pos() + *p ) ) {
5766 return;
5767 }
5768
5769 peek( u.pos() + *p );
5770}
cata::optional< tripoint > choose_direction(const std::string &message, const bool allow_vertical)
Request player input of a direction, possibly including vertical component.
Definition: action.cpp:981

References _, choose_direction(), map::impassable(), look_around(), m, map::obstructed_by_vehicle_rotation(), peek(), Character::pos(), u, and vertical_move().

Referenced by handle_action(), and peek().

◆ peek() [2/2]

void game::peek ( const tripoint p)

Definition at line 5772 of file game.cpp.

5773{
5774 u.moves -= 200;
5775 tripoint prev = u.pos();
5776 u.setpos( p );
5777 tripoint center = p;
5778 const look_around_result result = look_around( /*show_window=*/true, center, center, false, false,
5779 true );
5780 u.setpos( prev );
5781
5782 if( result.peek_action && *result.peek_action == PA_BLIND_THROW ) {
5783 item_location loc;
5784 avatar_action::plthrow( u, loc, p );
5785 }
5787}

References center, map::invalidate_map_cache(), look_around(), m, Creature::moves, PA_BLIND_THROW, avatar_action::plthrow(), Character::pos(), Character::setpos(), u, and tripoint::z.

◆ perhaps_add_random_npc()

void game::perhaps_add_random_npc ( )
private

Definition at line 11151 of file game.cpp.

11152{
11153 if( !calendar::once_every( 1_hours ) ) {
11154 return;
11155 }
11156 // Create a new NPC?
11157 // Only allow NPCs on 0 z-level, otherwise they can bug out due to lack of spots
11158 if( !get_option<bool>( "RANDOM_NPC" ) || ( !m.has_zlevels() && get_levz() != 0 ) ) {
11159 return;
11160 }
11161
11162 float density = get_option<float>( "NPC_DENSITY" );
11163 static constexpr int density_search_radius = 60;
11164 const float npc_num = overmap_buffer.get_npcs_near_player( density_search_radius ).size();
11165 if( npc_num > 0.0 ) {
11166 // 100%, 80%, 64%, 52%, 41%, 33%...
11167 density *= std::pow( 0.8f, npc_num );
11168 }
11169
11170 if( !x_in_y( density, 100 ) ) {
11171 return;
11172 }
11173 bool spawn_allowed = false;
11175 int counter = 0;
11176 while( !spawn_allowed ) {
11177 if( counter >= 10 ) {
11178 return;
11179 }
11180 static constexpr int radius_spawn_range = 120;
11181 const tripoint_abs_omt u_omt = u.global_omt_location();
11182 spawn_point = u_omt + point( rng( -radius_spawn_range, radius_spawn_range ),
11183 rng( -radius_spawn_range, radius_spawn_range ) );
11184 spawn_point.z() = 0;
11185 const oter_id oter = overmap_buffer.ter( spawn_point );
11186 // shouldn't spawn on lakes or rivers.
11187 if( !is_river_or_lake( oter ) ) {
11188 spawn_allowed = true;
11189 }
11190 counter += 1;
11191 }
11192 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
11193 tmp->normalize();
11194 tmp->randomize();
11195 std::string new_fac_id = "solo_";
11196 new_fac_id += tmp->name;
11197 // create a new "lone wolf" faction for this one NPC
11198 faction *new_solo_fac = faction_manager_ptr->add_new_faction( tmp->name, faction_id( new_fac_id ),
11199 faction_id( "no_faction" ) );
11200 tmp->set_fac( new_solo_fac ? new_solo_fac->id : faction_id( "no_faction" ) );
11201 // adds the npc to the correct overmap.
11202 // Only spawn random NPCs on z-level 0
11203 // TODO: fix point types
11204 tripoint submap_spawn = omt_to_sm_copy( spawn_point.raw() );
11205 tmp->spawn_at_sm( tripoint( submap_spawn.xy(), 0 ) );
11207 tmp->form_opinion( u );
11208 tmp->mission = NPC_MISSION_NULL;
11209 tmp->long_term_goal_action();
11210 tmp->add_new_mission( mission::reserve_random( ORIGIN_ANY_NPC, tmp->global_omt_location(),
11211 tmp->getID() ) );
11212 // This will make the new NPC active- if its nearby to the player
11213 load_npcs();
11214}
faction_id id
Definition: faction.h:82
point omt_to_sm_copy(const point &p)
@ ORIGIN_ANY_NPC
Definition: mission.h:46
bool is_river_or_lake(const oter_id &ter)
Definition: overmap.cpp:563

References faction_manager_ptr, get_levz(), overmapbuffer::get_npcs_near_player(), Character::global_omt_location(), map::has_zlevels(), faction_template::id, overmapbuffer::insert_npc(), is_river_or_lake(), load_npcs(), m, NPC_MISSION_NULL, omt_to_sm_copy(), calendar::once_every(), ORIGIN_ANY_NPC, overmap_buffer, mission::reserve_random(), rng(), overmapbuffer::ter(), u, x_in_y(), and tripoint::xy().

Referenced by do_turn().

◆ phasing_move()

bool game::phasing_move ( const tripoint dest,
bool  via_ramp = false 
)

Definition at line 9552 of file game.cpp.

9553{
9554 if( dest_loc.z != u.posz() && !via_ramp ) {
9555 // No vertical phasing yet
9556 return false;
9557 }
9558
9559 //probability travel through walls but not water
9560 tripoint dest = dest_loc;
9561 // tile is impassable
9562 int tunneldist = 0;
9563 const point d( sgn( dest.x - u.posx() ), sgn( dest.y - u.posy() ) );
9564 while( m.impassable( dest ) ||
9565 ( critter_at( dest ) != nullptr && tunneldist > 0 ) ) {
9566 //add 1 to tunnel distance for each impassable tile in the line
9567 tunneldist += 1;
9568 //Being dimensionally anchored prevents quantum shenanigans.
9569 if( u.worn_with_flag( "DIMENSIONAL_ANCHOR" ) || u.has_effect_with_flag( "DIMENSIONAL_ANCHOR" ) ) {
9571 _( "You try to quantum tunnel through the barrier, but something holds you back!" ) );
9572 return false;
9573 }
9574
9575 if( tunneldist > 24 ) {
9576 add_msg( m_info, _( "It's too dangerous to tunnel that far!" ) );
9577 return false;
9578 }
9579
9580 dest.x += d.x;
9581 dest.y += d.y;
9582 }
9583
9584 if( tunneldist != 0 ) {
9585 if( ( tunneldist - 1 ) * 100_kJ
9586 > //The first 100 was already taken up by the bionic's activation cost.
9587 u.get_power_level() ) { //oops, not enough energy! Tunneling costs 100 bionic power per impassable tile
9588 if( tunneldist * 100_kJ >
9590 add_msg( _( "You try to quantum tunnel through the barrier but bounce off! You don't have enough bionic power capacity to travel that far." ) );
9591 } else {
9592 add_msg( _( "You try to quantum tunnel through the barrier but are reflected! You need %i bionic power to travel that thickness of material." ),
9593 ( 100 * tunneldist ) );
9594 }
9595 return false;
9596 }
9597
9598 if( u.in_vehicle ) {
9599 m.unboard_vehicle( u.pos() );
9600 }
9601
9602 add_msg( _( "You quantum tunnel through the %d-tile wide barrier!" ), tunneldist );
9603 //tunneling costs 100 bionic power per impassable tile, but the first 100 was already drained by activation.
9604 u.mod_power_level( -( ( tunneldist - 1 ) * 100_kJ ) );
9605 //tunneling costs 100 moves baseline, 50 per extra tile up to a cap of 500 moves
9606 u.moves -= ( 50 + ( tunneldist * 50 ) );
9607 u.setpos( dest );
9608
9609 if( m.veh_at( u.pos() ).part_with_feature( "BOARDABLE", true ) ) {
9610 m.board_vehicle( u.pos(), &u );
9611 }
9612
9613 u.grab( OBJECT_NONE );
9615 m.creature_on_trap( u );
9616 return true;
9617 }
9618
9619 return false;
9620}
bool worn_with_flag(const std::string &flag, const bodypart_id &bp=bodypart_str_id::NULL_ID()) const
Returns true if the player is wearing an item with the given flag.
Definition: character.cpp:3270
units::energy get_max_power_level() const
Definition: character.cpp:1972
bool has_effect_with_flag(const std::string &flag, body_part bp=num_bp) const
Check if creature has any effect with the given flag.
Definition: creature.cpp:1201
void on_move_effects()
Definition: game.cpp:9820
void board_vehicle(const tripoint &p, player *pl)
Definition: map.cpp:1049
constexpr int sgn(const T x)
Definition: enums.h:8

References _, add_msg(), player::add_msg_if_player(), map::board_vehicle(), map::creature_on_trap(), critter_at(), Character::get_max_power_level(), Character::get_power_level(), avatar::grab(), Creature::has_effect_with_flag(), map::impassable(), Character::in_vehicle, m, m_info, Character::mod_power_level(), Creature::moves, OBJECT_NONE, on_move_effects(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), Character::setpos(), sgn(), u, map::unboard_vehicle(), map::veh_at(), Character::worn_with_flag(), point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

◆ pickup() [1/2]

void game::pickup ( )
private

Definition at line 5718 of file game.cpp.

5719{
5720 const cata::optional<tripoint> examp_ = choose_adjacent_highlight( _( "Pickup where?" ),
5721 _( "There is nothing to pick up nearby." ),
5722 ACTION_PICKUP, false );
5723 if( !examp_ ) {
5724 return;
5725 }
5726 pickup( *examp_ );
5727}

References _, ACTION_PICKUP, choose_adjacent_highlight(), and pickup().

Referenced by handle_action(), and pickup().

◆ pickup() [2/2]

void game::pickup ( const tripoint p)
private

Definition at line 5729 of file game.cpp.

5730{
5731 // Highlight target
5732 shared_ptr_fast<game::draw_callback_t> hilite_cb = make_shared_fast<game::draw_callback_t>( [&]() {
5733 m.drawsq( w_terrain, p, drawsq_params().highlight( true ) );
5734 } );
5735 add_draw_callback( hilite_cb );
5736
5737 pickup::pick_up( p, 0 );
5738}

References add_draw_callback(), map::drawsq(), m, pickup::pick_up(), and w_terrain.

◆ pickup_feet()

void game::pickup_feet ( )
private

Definition at line 5740 of file game.cpp.

5741{
5742 pickup::pick_up( u.pos(), 1 );
5743}

References pickup::pick_up(), Character::pos(), and u.

Referenced by handle_action().

◆ place_critter_around() [1/2]

monster * game::place_critter_around ( const mtype_id id,
const tripoint center,
int  radius 
)

Definition at line 4796 of file game.cpp.

4797{
4798 // TODO: change this into an assert, it must never happen.
4799 if( id.is_null() ) {
4800 return nullptr;
4801 }
4802 return place_critter_around( make_shared_fast<monster>( id ), center, radius );
4803}
monster * place_critter_around(const mtype_id &id, const tripoint &center, int radius)
Definition: game.cpp:4796

References center, and place_critter_around().

Referenced by place_critter_around(), place_critter_at(), replace_stair_monsters(), and start_game().

◆ place_critter_around() [2/2]

monster * game::place_critter_around ( const shared_ptr_fast< monster > &  mon,
const tripoint center,
int  radius,
bool  forced = false 
)

Definition at line 4805 of file game.cpp.

4809{
4811 if( forced || can_place_monster( *mon, center ) ) {
4812 where = center;
4813 }
4814
4815 // This loop ensures the monster is placed as close to the center as possible,
4816 // but all places that equally far from the center have the same probability.
4817 for( int r = 1; r <= radius && !where; ++r ) {
4819 }
4820
4821 if( !where ) {
4822 return nullptr;
4823 }
4824 mon->spawn( *where );
4825 return critter_tracker->add( mon ) ? mon.get() : nullptr;
4826}
static cata::optional< tripoint > choose_where_to_place_monster(const monster &mon, const tripoint_range< tripoint > &range)
Definition: game.cpp:4778
static bool can_place_monster(const monster &mon, const tripoint &p)
Definition: game.cpp:4762

References can_place_monster(), center, choose_where_to_place_monster(), critter_tracker, m, and map::points_in_radius().

◆ place_critter_at() [1/2]

monster * game::place_critter_at ( const mtype_id id,
const tripoint p 
)

Adds critters to the reality bubble, creating them if necessary.

Functions taking a id parameter will construct a monster based on that id, (with default properties). Functions taking a mon parameter will use the supplied monster instance instead (which must not be null). Note: the monster will not be upgraded by these functions, it is placed as is.

place_critter_at will place the creature exactly at the given point.

place_critter_around will place the creature around the center p within the given radius (radius 0 means only the center point is used). The chosen point will be as close to the center as possible.

place_critter_within will place the creature at a random point within that given range. (All points within have equal probability.)

Returns
All functions return null if the creature could not be placed (usually because the target is not suitable for it: may be a solid wall, or air, or already occupied by some creature). If the creature has been placed, it returns a pointer to it (which is the same as the one contained in mon).

Definition at line 4786 of file game.cpp.

4787{
4788 return place_critter_around( id, p, 0 );
4789}

References place_critter_around().

Referenced by fungal_effects::fungalize(), revive_corpse(), fungal_effects::spread_fungus_one_tile(), and update_stair_monsters().

◆ place_critter_at() [2/2]

monster * game::place_critter_at ( const shared_ptr_fast< monster > &  mon,
const tripoint p 
)

Definition at line 4791 of file game.cpp.

4792{
4793 return place_critter_around( mon, p, 0 );
4794}

References place_critter_around().

◆ place_critter_within() [1/2]

monster * game::place_critter_within ( const mtype_id id,
const tripoint_range< tripoint > &  range 
)

Definition at line 4828 of file game.cpp.

4829{
4830 // TODO: change this into an assert, it must never happen.
4831 if( id.is_null() ) {
4832 return nullptr;
4833 }
4834 return place_critter_within( make_shared_fast<monster>( id ), range );
4835}
monster * place_critter_within(const mtype_id &id, const tripoint_range< tripoint > &range)
Definition: game.cpp:4828

References place_critter_within().

Referenced by place_critter_within().

◆ place_critter_within() [2/2]

monster * game::place_critter_within ( const shared_ptr_fast< monster > &  mon,
const tripoint_range< tripoint > &  range 
)

Definition at line 4837 of file game.cpp.

4839{
4840 const cata::optional<tripoint> where = choose_where_to_place_monster( *mon, range );
4841 if( !where ) {
4842 return nullptr;
4843 }
4844 mon->spawn( *where );
4845 return critter_tracker->add( mon ) ? mon.get() : nullptr;
4846}

References choose_where_to_place_monster(), and critter_tracker.

◆ place_player()

point game::place_player ( const tripoint dest)
Dexterity increases chance of avoiding cuts on sharp terrain

Definition at line 9190 of file game.cpp.

9191{
9192 const optional_vpart_position vp1 = m.veh_at( dest_loc );
9193 if( const cata::optional<std::string> label = vp1.get_label() ) {
9194 add_msg( m_info, _( "Label here: %s" ), *label );
9195 }
9196 std::string signage = m.get_signage( dest_loc );
9197 if( !signage.empty() ) {
9198 if( !u.has_trait( trait_ILLITERATE ) ) {
9199 add_msg( m_info, _( "The sign says: %s" ), signage );
9200 } else {
9201 add_msg( m_info, _( "There is a sign here, but you are unable to read it." ) );
9202 }
9203 }
9204 if( m.has_graffiti_at( dest_loc ) ) {
9205 if( !u.has_trait( trait_ILLITERATE ) ) {
9206 add_msg( m_info, _( "Written here: %s" ), m.graffiti_at( dest_loc ) );
9207 } else {
9208 add_msg( m_info, _( "Something is written here, but you are unable to read it." ) );
9209 }
9210 }
9211 // TODO: Move the stuff below to a Character method so that NPCs can reuse it
9212 if( m.has_flag( "ROUGH", dest_loc ) && ( !u.in_vehicle ) && ( !u.is_mounted() ) ) {
9213 if( one_in( 5 ) && u.get_armor_bash( bodypart_id( "foot_l" ) ) < rng( 2, 5 ) ) {
9214 add_msg( m_bad, _( "You hurt your left foot on the %s!" ),
9215 m.has_flag_ter( "ROUGH", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9216 dest_loc ) );
9217 u.deal_damage( nullptr, bodypart_id( "foot_l" ), damage_instance( DT_CUT, 1 ) );
9218 }
9219 if( one_in( 5 ) && u.get_armor_bash( bodypart_id( "foot_r" ) ) < rng( 2, 5 ) ) {
9220 add_msg( m_bad, _( "You hurt your right foot on the %s!" ),
9221 m.has_flag_ter( "ROUGH", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9222 dest_loc ) );
9223 u.deal_damage( nullptr, bodypart_id( "foot_l" ), damage_instance( DT_CUT, 1 ) );
9224 }
9225 }
9226 ///\EFFECT_DEX increases chance of avoiding cuts on sharp terrain
9227 if( m.has_flag( "SHARP", dest_loc ) && !one_in( 3 ) && !x_in_y( 1 + u.dex_cur / 2.0, 40 ) &&
9228 ( !u.in_vehicle && !m.veh_at( dest_loc ) ) && ( !u.has_trait( trait_PARKOUR ) ||
9229 one_in( 4 ) ) && ( u.has_trait( trait_THICKSKIN ) ? !one_in( 8 ) : true ) ) {
9230 if( u.is_mounted() ) {
9231 add_msg( _( "Your %s gets cut!" ), u.mounted_creature->get_name() );
9232 u.mounted_creature->apply_damage( nullptr, bodypart_id( "torso" ), rng( 1, 10 ) );
9233 } else {
9234 const bodypart_id bp = u.get_random_body_part();
9235 if( u.deal_damage( nullptr, bp, damage_instance( DT_CUT, rng( 1, 10 ) ) ).total_damage() > 0 ) {
9236 //~ 1$s - bodypart name in accusative, 2$s is terrain name.
9237 add_msg( m_bad, _( "You cut your %1$s on the %2$s!" ),
9238 body_part_name_accusative( bp->token ),
9239 m.has_flag_ter( "SHARP", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9240 dest_loc ) );
9241 }
9242 }
9243 }
9244 if( m.has_flag( "UNSTABLE", dest_loc ) && !u.is_mounted() ) {
9245 u.add_effect( effect_bouldering, 1_turns, num_bp );
9246 } else if( u.has_effect( effect_bouldering ) ) {
9248 }
9249 if( m.has_flag_ter_or_furn( TFLAG_NO_SIGHT, dest_loc ) ) {
9250 u.add_effect( effect_no_sight, 1_turns, num_bp );
9251 } else if( u.has_effect( effect_no_sight ) ) {
9253 }
9254
9255 // If we moved out of the nonant, we need update our map data
9256 if( m.has_flag( "SWIMMABLE", dest_loc ) && u.has_effect( effect_onfire ) ) {
9257 add_msg( _( "The water puts out the flames!" ) );
9259 if( u.is_mounted() ) {
9260 monster *mon = u.mounted_creature.get();
9261 if( mon->has_effect( effect_onfire ) ) {
9263 }
9264 }
9265 }
9266
9267 if( monster *const mon_ptr = critter_at<monster>( dest_loc ) ) {
9268 // We displaced a monster. It's probably a bug if it wasn't a friendly mon...
9269 // Immobile monsters can't be displaced.
9270 monster &critter = *mon_ptr;
9271 // TODO: handling for ridden creatures other than players mount.
9272 if( !critter.has_effect( effect_ridden ) ) {
9273 if( u.is_mounted() ) {
9274 std::vector<tripoint> valid;
9275 for( const tripoint &jk : m.points_in_radius( critter.pos(), 1 ) ) {
9276 if( is_empty( jk ) ) {
9277 valid.push_back( jk );
9278 }
9279 }
9280 if( !valid.empty() ) {
9281 critter.move_to( random_entry( valid ) );
9282 add_msg( _( "You push the %s out of the way." ), critter.name() );
9283 } else {
9284 add_msg( _( "There is no room to push the %s out of the way." ), critter.name() );
9285 return u.pos().xy();
9286 }
9287 } else {
9288 critter.move_to( u.pos(), false,
9289 true ); // Force the movement even though the player is there right now.
9290 add_msg( _( "You displace the %s." ), critter.name() );
9291 }
9292 } else if( !u.has_effect( effect_riding ) ) {
9293 add_msg( _( "You cannot move the %s out of the way." ), critter.name() );
9294 return u.pos().xy();
9295 }
9296 }
9297
9298 // If the player is in a vehicle, unboard them from the current part
9299 if( u.in_vehicle ) {
9300 m.unboard_vehicle( u.pos() );
9301 }
9302 // Move the player
9303 // Start with z-level, to make it less likely that old functions (2D ones) freak out
9304 if( m.has_zlevels() && dest_loc.z != get_levz() ) {
9305 vertical_shift( dest_loc.z );
9306 }
9307
9308 if( u.is_hauling() && ( !m.can_put_items( dest_loc ) ||
9309 m.has_flag( TFLAG_DEEP_WATER, dest_loc ) ||
9310 vp1 ) ) {
9311 u.stop_hauling();
9312 }
9313 u.setpos( dest_loc );
9314 if( u.is_mounted() ) {
9315 monster *mon = u.mounted_creature.get();
9316 mon->setpos( dest_loc );
9317 mon->process_triggers();
9318 m.creature_in_field( *mon );
9319 }
9320 point submap_shift = update_map( u );
9321 // Important: don't use dest_loc after this line. `update_map` may have shifted the map
9322 // and dest_loc was not adjusted and therefore is still in the un-shifted system and probably wrong.
9323 // If you must use it you can calculate the position in the new, shifted system with
9324 // adjusted_pos = ( old_pos.x - submap_shift.x * SEEX, old_pos.y - submap_shift.y * SEEY, old_pos.z )
9325
9326 //Auto pulp or butcher and Auto foraging
9327 if( get_option<bool>( "AUTO_FEATURES" ) && mostseen == 0 && !u.is_mounted() ) {
9329
9330 const std::string forage_type = get_option<std::string>( "AUTO_FORAGING" );
9331 if( forage_type != "off" ) {
9332 const auto forage = [&]( const tripoint & pos ) {
9333 const auto &xter_t = m.ter( pos ).obj().examine;
9334 const auto &xfurn_t = m.furn( pos ).obj().examine;
9335 const bool forage_everything = forage_type == "both";
9336 const bool forage_bushes = forage_everything || forage_type == "bushes";
9337 const bool forage_trees = forage_everything || forage_type == "trees";
9338 if( xter_t == &iexamine::none ) {
9339 return;
9340 } else if( ( forage_bushes && xter_t == &iexamine::shrub_marloss ) ||
9341 ( forage_bushes && xter_t == &iexamine::shrub_wildveggies ) ||
9342 ( forage_bushes && xter_t == &iexamine::harvest_ter_nectar ) ||
9343 ( forage_trees && xter_t == &iexamine::tree_marloss ) ||
9344 ( forage_trees && xter_t == &iexamine::harvest_ter ) ||
9345 ( forage_trees && xter_t == &iexamine::harvest_ter_nectar )
9346 ) {
9347 xter_t( u, pos );
9348 } else if( ( forage_everything && xfurn_t == &iexamine::harvest_furn ) ||
9349 ( forage_everything && xfurn_t == &iexamine::harvest_furn_nectar )
9350 ) {
9351 xfurn_t( u, pos );
9352 }
9353 };
9354
9355 for( auto &elem : adjacentDir ) {
9356 forage( u.pos() + direction_XY( elem ) );
9357 }
9358 }
9359
9360 const std::string pulp_butcher = get_option<std::string>( "AUTO_PULP_BUTCHER" );
9361 if( pulp_butcher == "butcher" && u.max_quality( quality_id( "BUTCHER" ) ) > INT_MIN ) {
9362 std::vector<item *> corpses;
9363
9364 for( item &it : m.i_at( u.pos() ) ) {
9365 corpses.push_back( &it );
9366 }
9367
9368 if( !corpses.empty() ) {
9369 u.assign_activity( activity_id( "ACT_BUTCHER" ), 0, true );
9370 for( item *it : corpses ) {
9371 u.activity.targets.emplace_back( map_cursor( u.pos() ), it );
9372 }
9373 }
9374 } else if( pulp_butcher == "pulp" || pulp_butcher == "pulp_adjacent" ) {
9375 const auto pulp = [&]( const tripoint & pos ) {
9376 for( const auto &maybe_corpse : m.i_at( pos ) ) {
9377 if( maybe_corpse.is_corpse() && maybe_corpse.can_revive() &&
9378 !maybe_corpse.get_mtype()->bloodType().obj().has_acid ) {
9380 u.activity.placement = m.getabs( pos );
9381 u.activity.auto_resume = true;
9382 u.activity.str_values.push_back( "auto_pulp_no_acid" );
9383 return;
9384 }
9385 }
9386 };
9387
9388 if( pulp_butcher == "pulp_adjacent" ) {
9389 for( auto &elem : adjacentDir ) {
9390 pulp( u.pos() + direction_XY( elem ) );
9391 }
9392 } else {
9393 pulp( u.pos() );
9394 }
9395 }
9396 }
9397
9398 //Autopickup
9399 if( !u.is_mounted() && get_option<bool>( "AUTO_PICKUP" ) && !u.is_hauling() &&
9400 ( !get_option<bool>( "AUTO_PICKUP_SAFEMODE" ) || mostseen == 0 ) &&
9401 ( m.has_items( u.pos() ) || get_option<bool>( "AUTO_PICKUP_ADJACENT" ) ) ) {
9402 pickup::pick_up( u.pos(), -1 );
9403 }
9404
9405 // If the new tile is a boardable part, board it
9406 if( vp1.part_with_feature( "BOARDABLE", true ) && !u.is_mounted() ) {
9407 m.board_vehicle( u.pos(), &u );
9408 }
9409
9410 // Traps!
9411 // Try to detect.
9413 if( u.is_mounted() ) {
9415 } else {
9416 m.creature_on_trap( u );
9417 }
9418 // Drench the player if swimmable
9419 if( m.has_flag( "SWIMMABLE", u.pos() ) &&
9420 !( u.is_mounted() || ( u.in_vehicle && vp1->vehicle().can_float() ) ) ) {
9421 u.drench( 40, { { bp_foot_l, bp_foot_r, bp_leg_l, bp_leg_r } }, false );
9422 }
9423
9424 // List items here
9425 if( !m.has_flag( "SEALED", u.pos() ) ) {
9426 if( get_option<bool>( "NO_AUTO_PICKUP_ZONES_LIST_ITEMS" ) ||
9427 !check_zone( zone_type_id( "NO_AUTO_PICKUP" ), u.pos() ) ) {
9428 if( u.is_blind() && !m.i_at( u.pos() ).empty() ) {
9429 add_msg( _( "There's something here, but you can't see what it is." ) );
9430 } else if( m.has_items( u.pos() ) ) {
9431 std::vector<std::string> names;
9432 std::vector<size_t> counts;
9433 std::vector<item> items;
9434 for( auto &tmpitem : m.i_at( u.pos() ) ) {
9435
9436 std::string next_tname = tmpitem.tname();
9437 std::string next_dname = tmpitem.display_name();
9438 bool by_charges = tmpitem.count_by_charges();
9439 bool got_it = false;
9440 for( size_t i = 0; i < names.size(); ++i ) {
9441 if( by_charges && next_tname == names[i] ) {
9442 counts[i] += tmpitem.charges;
9443 got_it = true;
9444 break;
9445 } else if( next_dname == names[i] ) {
9446 counts[i] += 1;
9447 got_it = true;
9448 break;
9449 }
9450 }
9451 if( !got_it ) {
9452 if( by_charges ) {
9453 names.push_back( tmpitem.tname( tmpitem.charges ) );
9454 counts.push_back( tmpitem.charges );
9455 } else {
9456 names.push_back( tmpitem.display_name( 1 ) );
9457 counts.push_back( 1 );
9458 }
9459 items.push_back( tmpitem );
9460 }
9461 if( names.size() > 10 ) {
9462 break;
9463 }
9464 }
9465 for( size_t i = 0; i < names.size(); ++i ) {
9466 if( !items[i].count_by_charges() ) {
9467 names[i] = items[i].display_name( counts[i] );
9468 } else {
9469 names[i] = items[i].tname( counts[i] );
9470 }
9471 }
9472 int and_the_rest = 0;
9473 for( size_t i = 0; i < names.size(); ++i ) {
9474 //~ number of items: "<number> <item>"
9475 std::string fmt = vgettext( "%1$d %2$s", "%1$d %2$s", counts[i] );
9476 names[i] = string_format( fmt, counts[i], names[i] );
9477 // Skip the first two.
9478 if( i > 1 ) {
9479 and_the_rest += counts[i];
9480 }
9481 }
9482 if( names.size() == 1 ) {
9483 add_msg( _( "You see here %s." ), names[0] );
9484 } else if( names.size() == 2 ) {
9485 add_msg( _( "You see here %s and %s." ), names[0], names[1] );
9486 } else if( names.size() == 3 ) {
9487 add_msg( _( "You see here %s, %s, and %s." ), names[0], names[1], names[2] );
9488 } else if( and_the_rest < 7 ) {
9489 add_msg( vgettext( "You see here %s, %s and %d more item.",
9490 "You see here %s, %s and %d more items.",
9491 and_the_rest ),
9492 names[0], names[1], and_the_rest );
9493 } else {
9494 add_msg( _( "You see here %s and many more items." ), names[0] );
9495 }
9496 }
9497 }
9498 }
9499
9500 if( ( vp1.part_with_feature( "CONTROL_ANIMAL", true ) ||
9501 vp1.part_with_feature( "CONTROLS", true ) ) && u.in_vehicle && !u.is_mounted() ) {
9502 add_msg( _( "There are vehicle controls here." ) );
9503 if( !u.has_trait( trait_id( "WAYFARER" ) ) ) {
9504 add_msg( m_info, _( "%s to drive." ), press_x( ACTION_CONTROL_VEHICLE ) );
9505 }
9506 } else if( vp1.part_with_feature( "CONTROLS", true ) && u.in_vehicle &&
9507 u.is_mounted() ) {
9508 add_msg( _( "There are vehicle controls here but you cannot reach them whilst mounted." ) );
9509 }
9510 return submap_shift;
9511}
std::string body_part_name_accusative(body_part bp, int number)
Returns the matching accusative name of the body_part token, i.e.
Definition: bodypart.cpp:329
void drench(int saturation, const body_part_set &flags, bool ignore_waterproof)
Drenches the player with water, saturation is the percent gotten wet.
Definition: suffer.cpp:1754
bool is_hauling() const
Definition: character.cpp:9189
void stop_hauling()
Definition: character.cpp:9180
bodypart_id get_random_body_part(bool main=false) const
Definition: creature.cpp:1620
void vertical_shift(int z_after)
Actual z-level movement part of vertical_move.
Definition: game.cpp:10674
bool check_zone(const zone_type_id &type, const tripoint &where) const
Definition: game.cpp:6128
std::string furnname(const tripoint &p)
Definition: map.cpp:1469
bool has_flag_ter_or_furn(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2322
bool has_graffiti_at(const tripoint &p) const
Definition: map.cpp:7833
bool has_items(const tripoint &p) const
Checks for existence of items.
Definition: map.cpp:4760
const std::string & graffiti_at(const tripoint &p) const
Definition: map.cpp:7822
bool has_flag_ter(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2312
bool can_put_items(const tripoint &p) const
Definition: map.cpp:2298
void setpos(const tripoint &p) override
Definition: monster.cpp:238
bool move_to(const tripoint &p, bool force=false, bool step_on_critter=false, float stagger_adjustment=1.0)
Attempt to move to p.
Definition: monmove.cpp:1527
void process_triggers()
Definition: monster.cpp:1212
cata::optional< std::string > get_label() const
std::vector< std::string > str_values
bool auto_resume
If true, the activity will be auto-resumed next time the player attempts an identical activity.
void search_surroundings()
Search surrounding squares for traps (and maybe other things in the future).
Definition: player.cpp:701
static const efftype_id effect_riding("riding")
static const trait_id trait_ILLITERATE("ILLITERATE")
static const efftype_id effect_bouldering("bouldering")
static const trait_id trait_PARKOUR("PARKOUR")
static const efftype_id effect_no_sight("no_sight")
static const trait_id trait_THICKSKIN("THICKSKIN")
static const efftype_id effect_onfire("onfire")
point direction_XY(const direction dir)
Definition: line.cpp:433
@ TFLAG_NO_SIGHT
Definition: mapdata.h:283
@ TFLAG_DEEP_WATER
Definition: mapdata.h:301
static std::map< nameFlags, std::vector< std::string > > names
Definition: name.cpp:18
const int INDEFINITELY_LONG
A number that represents the longest possible action.
void shrub_wildveggies(player &p, const tripoint &examp)
Definition: iexamine.cpp:3658
void shrub_marloss(player &p, const tripoint &examp)
Definition: iexamine.cpp:3623
void harvest_ter(player &p, const tripoint &examp)
Definition: iexamine.cpp:2095
void harvest_furn(player &p, const tripoint &examp)
Definition: iexamine.cpp:2074
void harvest_ter_nectar(player &p, const tripoint &examp)
Definition: iexamine.cpp:2083
void harvest_furn_nectar(player &p, const tripoint &examp)
Definition: iexamine.cpp:2065
void tree_marloss(player &p, const tripoint &examp)
Definition: iexamine.cpp:3637
string_id< zone_type > zone_type_id
Definition: type_id.h:199

References _, ACTION_CONTROL_VEHICLE, Character::activity, Creature::add_effect(), add_msg(), Character::assign_activity(), player_activity::auto_resume, map::board_vehicle(), body_part_name_accusative(), bp_foot_l, bp_foot_r, bp_leg_l, bp_leg_r, map::can_put_items(), check_zone(), map::creature_in_field(), map::creature_on_trap(), Character::deal_damage(), Character::dex_cur, direction_XY(), Character::drench(), DT_CUT, EAST, effect_bouldering, effect_no_sight, effect_onfire, effect_ridden, effect_riding, item_stack::empty(), map_data_common_t::examine, map::furn(), map::furnname(), Character::get_armor_bash(), optional_vpart_position::get_label(), get_levz(), Creature::get_random_body_part(), map::get_signage(), map::getabs(), map::graffiti_at(), iexamine::harvest_furn(), iexamine::harvest_furn_nectar(), iexamine::harvest_ter(), iexamine::harvest_ter_nectar(), Creature::has_effect(), map::has_flag(), map::has_flag_ter(), map::has_flag_ter_or_furn(), map::has_graffiti_at(), map::has_items(), Character::has_trait(), map::has_zlevels(), map::i_at(), Character::in_vehicle, calendar::INDEFINITELY_LONG, Character::is_blind(), is_empty(), Character::is_hauling(), Character::is_mounted(), m, m_bad, m_info, visitable< T >::max_quality(), mostseen, Character::mounted_creature, monster::move_to(), monster::name(), Name::names, iexamine::none(), NORTH, NORTHEAST, NORTHWEST, num_bp, int_id< T >::obj(), one_in(), optional_vpart_position::part_with_feature(), pickup::pick_up(), player_activity::placement, map::points_in_radius(), Character::pos(), monster::pos(), press_x(), monster::process_triggers(), random_entry(), Creature::remove_effect(), rng(), player::search_surroundings(), Character::setpos(), monster::setpos(), iexamine::shrub_marloss(), iexamine::shrub_wildveggies(), SOUTH, SOUTHEAST, SOUTHWEST, Character::stop_hauling(), player_activity::str_values, string_format(), player_activity::targets, map::ter(), map::tername(), TFLAG_DEEP_WATER, TFLAG_NO_SIGHT, trait_ILLITERATE, trait_PARKOUR, trait_THICKSKIN, iexamine::tree_marloss(), u, map::unboard_vehicle(), update_map(), map::veh_at(), vertical_shift(), vgettext(), WEST, x_in_y(), tripoint::xy(), and tripoint::z.

Referenced by place_player_overmap(), and walk_move().

◆ place_player_overmap()

void game::place_player_overmap ( const tripoint_abs_omt om_dest)

Definition at line 9513 of file game.cpp.

9514{
9515 // if player is teleporting around, they don't bring their horse with them
9516 if( u.is_mounted() ) {
9518 u.mounted_creature->remove_effect( effect_ridden );
9519 u.mounted_creature = nullptr;
9520 }
9521 // offload the active npcs.
9522 unload_npcs();
9523 for( monster &critter : all_monsters() ) {
9524 despawn_monster( critter );
9525 }
9526 if( u.in_vehicle ) {
9527 m.unboard_vehicle( u.pos() );
9528 }
9529
9531 const int minz = m.has_zlevels() ? -OVERMAP_DEPTH : get_levz();
9532 const int maxz = m.has_zlevels() ? OVERMAP_HEIGHT : get_levz();
9533 for( int z = minz; z <= maxz; z++ ) {
9534 m.clear_vehicle_list( z );
9535 }
9537 // offset because load_map expects the coordinates of the top left corner, but the
9538 // player will be centered in the middle of the map.
9539 // TODO: fix point types
9540 const tripoint map_sm_pos(
9541 project_to<coords::sm>( om_dest ).raw() + point( -HALF_MAPSIZE, -HALF_MAPSIZE ) );
9542 const tripoint player_pos( u.pos().xy(), map_sm_pos.z );
9543 load_map( map_sm_pos );
9544 load_npcs();
9545 m.spawn_monsters( true ); // Static monsters
9547 // update weather now as it could be different on the new location
9549 place_player( player_pos );
9550}
point place_player(const tripoint &dest)
Definition: game.cpp:9190
void unload_npcs()
Unloads all NPCs.
Definition: game.cpp:967
void update_overmap_seen()
Definition: game.cpp:10852
level_cache & access_cache(int zlev)
Definition: map.cpp:8705
void clear_vehicle_list(int zlev)
Definition: map.cpp:331
void clear_vehicle_cache()
Definition: map.cpp:313
std::bitset< MAPSIZE_X *MAPSIZE_Y > map_memory_seen_cache
Definition: map.h:356

References map::access_cache(), all_monsters(), map::clear_vehicle_cache(), map::clear_vehicle_list(), despawn_monster(), effect_ridden, effect_riding, get_levz(), get_weather, HALF_MAPSIZE, map::has_zlevels(), Character::in_vehicle, Character::is_mounted(), load_map(), load_npcs(), m, level_cache::map_memory_seen_cache, Character::mounted_creature, weather_manager::nextweather, OVERMAP_DEPTH, OVERMAP_HEIGHT, place_player(), Character::pos(), Creature::remove_effect(), map::spawn_monsters(), calendar::turn, u, map::unboard_vehicle(), unload_npcs(), update_overmap_seen(), tripoint::xy(), and tripoint::z.

◆ place_vehicle_nearby()

vehicle * game::place_vehicle_nearby ( const vproto_id id,
const point_abs_omt origin,
int  min_distance,
int  max_distance,
const std::vector< std::string > &  omt_search_types = {} 
)
private

Definition at line 863 of file game.cpp.

866{
867 std::vector<std::string> search_types = omt_search_types;
868 if( search_types.empty() ) {
869 vehicle veh( id );
870 if( veh.can_float() ) {
871 search_types.push_back( "river" );
872 search_types.push_back( "lake" );
873 } else {
874 search_types.push_back( "field" );
875 search_types.push_back( "road" );
876 }
877 }
878 for( const std::string &search_type : search_types ) {
879 omt_find_params find_params;
880 find_params.must_see = false;
881 find_params.cant_see = false;
882 find_params.types.emplace_back( search_type, ot_match_type::type );
883 // find nearest road
884 find_params.min_distance = min_distance;
885 find_params.search_range = max_distance;
886 // if player spawns underground, park their car on the surface.
887 const tripoint_abs_omt omt_origin( origin, 0 );
888 for( const tripoint_abs_omt &goal : overmap_buffer.find_all( omt_origin, find_params ) ) {
889 // try place vehicle there.
890 tinymap target_map;
891 target_map.load( project_to<coords::sm>( goal ), false );
892 const tripoint tinymap_center( SEEX, SEEY, goal.z() );
893 static constexpr std::array<units::angle, 4> angles = {{
894 0_degrees, 90_degrees, 180_degrees, 270_degrees
895 }
896 };
897 vehicle *veh = target_map.add_vehicle(
898 id, tinymap_center, random_entry( angles ), rng( 50, 80 ), 0, false );
899 if( veh ) {
900 tripoint abs_local = m.getlocal( target_map.getabs( tinymap_center ) );
901 veh->sm_pos = ms_to_sm_remain( abs_local );
902 veh->pos = abs_local.xy();
904 veh->tracking_on = true;
905 target_map.save();
906 return veh;
907 }
908 }
909 }
910 return nullptr;
911}
void save()
Add currently loaded submaps (in grid) to the mapbuffer.
Definition: map.cpp:6594
vehicle * add_vehicle(const vgroup_id &type, const tripoint &p, units::angle dir, int init_veh_fuel=-1, int init_veh_status=-1, bool merge_wrecks=true)
Definition: mapgen.cpp:5604
void add_vehicle(vehicle *veh)
Add the vehicle to be tracked in the overmap.
std::vector< tripoint_abs_omt > find_all(const tripoint_abs_omt &origin, const omt_find_params &params)
Find all places with the specific overmap terrain type.
Definition: map.h:2095
point pos
Position of the vehicle inside the submap that contains the vehicle.
Definition: vehicle.h:1916
tripoint sm_pos
Submap coordinates of the currently loaded submap (see game::m) that contains this vehicle.
Definition: vehicle.h:1901
bool tracking_on
Definition: vehicle.h:1991
point ms_to_sm_remain(int &x, int &y)
static constexpr int SEEY
Standard arguments for finding overmap terrain.
std::vector< std::pair< std::string, ot_match_type > > types

References map::add_vehicle(), overmapbuffer::add_vehicle(), vehicle::can_float(), omt_find_params::cant_see, overmapbuffer::find_all(), map::getabs(), map::getlocal(), map::load(), m, omt_find_params::min_distance, ms_to_sm_remain(), omt_find_params::must_see, overmap_buffer, vehicle::pos, random_entry(), rng(), map::save(), omt_find_params::search_range, SEEX, SEEY, vehicle::sm_pos, vehicle::tracking_on, type, omt_find_params::types, and tripoint::xy().

Referenced by start_game().

◆ pre_print_all_tile_info()

void game::pre_print_all_tile_info ( const tripoint lp,
const catacurses::window w_info,
int &  line,
int  last_line,
const visibility_variables cache 
)

Definition at line 6670 of file game.cpp.

6673{
6674 // get global area info according to look_around caret position
6675 // TODO: fix point types
6677 lp ) ) ) );
6678 // we only need the area name and then pass it to print_all_tile_info() function below
6679 const std::string area_name = cur_ter_m->get_name();
6680 print_all_tile_info( lp, w_info, area_name, 1, first_line, last_line, cache );
6681}
void print_all_tile_info(const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line, int last_line, const visibility_variables &cache)
Definition: game.cpp:5850
point ms_to_omt_copy(const point &p)
coords::coord_point< tripoint, coords::origin::abs, coords::omt > tripoint_abs_omt
Definition: coordinates.h:493
std::string get_name() const
Definition: omdata.h:205

References oter_t::get_name(), map::getabs(), m, ms_to_omt_copy(), overmap_buffer, print_all_tile_info(), and overmapbuffer::ter().

Referenced by look_around().

◆ print_all_tile_info()

void game::print_all_tile_info ( const tripoint lp,
const catacurses::window w_look,
const std::string &  area_name,
int  column,
int &  line,
int  last_line,
const visibility_variables cache 
)

Definition at line 5850 of file game.cpp.

5855{
5856 visibility_type visibility = VIS_HIDDEN;
5857 const bool inbounds = m.inbounds( lp );
5858 if( inbounds ) {
5859 visibility = m.get_visibility( m.apparent_light_at( lp, cache ), cache );
5860 }
5861 const Creature *creature = critter_at( lp, true );
5862 switch( visibility ) {
5863 case VIS_CLEAR: {
5864 const optional_vpart_position vp = m.veh_at( lp );
5865 print_terrain_info( lp, w_look, area_name, column, line );
5866 print_fields_info( lp, w_look, column, line );
5867 print_trap_info( lp, w_look, column, line );
5868 print_creature_info( creature, w_look, column, line, last_line );
5869 print_vehicle_info( veh_pointer_or_null( vp ), vp ? vp->part_index() : -1, w_look, column, line,
5870 last_line );
5871 print_items_info( lp, w_look, column, line, last_line );
5872 print_graffiti_info( lp, w_look, column, line, last_line );
5873 }
5874 break;
5875 case VIS_BOOMER:
5876 case VIS_BOOMER_DARK:
5877 case VIS_DARK:
5878 case VIS_LIT:
5879 case VIS_HIDDEN:
5880 print_visibility_info( w_look, column, line, visibility );
5881
5882 if( creature != nullptr ) {
5883 std::vector<std::string> buf;
5884 if( u.sees_with_infrared( *creature ) ) {
5885 creature->describe_infrared( buf );
5886 } else if( u.sees_with_specials( *creature ) ) {
5887 creature->describe_specials( buf );
5888 }
5889 for( const std::string &s : buf ) {
5890 mvwprintw( w_look, point( 1, ++line ), s );
5891 }
5892 }
5893 break;
5894 }
5895 if( !inbounds ) {
5896 return;
5897 }
5898 auto this_sound = sounds::sound_at( lp );
5899 if( !this_sound.empty() ) {
5900 mvwprintw( w_look, point( 1, ++line ), _( "You heard %s from here." ), this_sound );
5901 } else {
5902 // Check other z-levels
5903 tripoint tmp = lp;
5904 for( tmp.z = -OVERMAP_DEPTH; tmp.z <= OVERMAP_HEIGHT; tmp.z++ ) {
5905 if( tmp.z == lp.z ) {
5906 continue;
5907 }
5908
5909 auto zlev_sound = sounds::sound_at( tmp );
5910 if( !zlev_sound.empty() ) {
5911 mvwprintw( w_look, point( 1, ++line ), tmp.z > lp.z ?
5912 _( "You heard %s from above." ) : _( "You heard %s from below." ), zlev_sound );
5913 }
5914 }
5915 }
5916}
bool sees_with_specials(const Creature &critter) const
Definition: character.cpp:6425
bool sees_with_infrared(const Creature &critter) const
Check whether the this player can see the other creature with infrared.
void print_fields_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line)
Definition: game.cpp:6020
void print_terrain_info(const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line)
Definition: game.cpp:5947
void print_graffiti_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6112
void print_creature_info(const Creature *creature, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6057
void print_vehicle_info(const vehicle *veh, int veh_part, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6066
void print_items_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6075
void print_visibility_info(const catacurses::window &w_look, int column, int &line, visibility_type visibility)
Definition: game.cpp:5918
void print_trap_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line)
Definition: game.cpp:6038
void line(map *m, const ter_id &type, const point &p1, const point &p2)
Definition: mapgen.cpp:6459
std::string sound_at(const tripoint &location)
Definition: sounds.cpp:605

References _, map::apparent_light_at(), creature, critter_at(), map::get_visibility(), map::inbounds(), line(), m, catacurses::mvwprintw(), OVERMAP_DEPTH, OVERMAP_HEIGHT, print_creature_info(), print_fields_info(), print_graffiti_info(), print_items_info(), print_terrain_info(), print_trap_info(), print_vehicle_info(), print_visibility_info(), Character::sees_with_infrared(), Character::sees_with_specials(), sounds::sound_at(), u, map::veh_at(), veh_pointer_or_null(), VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, VIS_LIT, and tripoint::z.

Referenced by pre_print_all_tile_info().

◆ print_creature_info()

void game::print_creature_info ( const Creature creature,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6057 of file game.cpp.

6059{
6060 int vLines = last_line - line;
6061 if( creature != nullptr && ( u.sees( *creature ) || creature == &u ) ) {
6062 line = creature->print_info( w_look, ++line, vLines, column );
6063 }
6064}

References creature, line(), Character::sees(), and u.

Referenced by print_all_tile_info().

◆ print_fields_info()

void game::print_fields_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line 
)
private

Definition at line 6020 of file game.cpp.

6022{
6023 const field &tmpfield = m.field_at( lp );
6024 for( auto &fld : tmpfield ) {
6025 const field_entry &cur = fld.second;
6026 if( fld.first.obj().has_fire && ( m.has_flag( TFLAG_FIRE_CONTAINER, lp ) ||
6027 m.ter( lp ) == t_pit_shallow || m.ter( lp ) == t_pit ) ) {
6028 const int max_width = getmaxx( w_look ) - column - 2;
6029 int lines = fold_and_print( w_look, point( column, ++line ), max_width, cur.color(),
6030 get_fire_fuel_string( lp ) ) - 1;
6031 line += lines;
6032 } else {
6033 mvwprintz( w_look, point( column, ++line ), cur.color(), cur.name() );
6034 }
6035 }
6036}
An active or passive effect existing on a tile.
Definition: field.h:20
nc_color color() const
Definition: field.cpp:94
std::string name() const
Definition: field.h:84
A variable sized collection of field entries on a given map square.
Definition: field.h:131
ter_id t_pit_shallow
Definition: mapdata.cpp:625
ter_id t_pit
Definition: mapdata.cpp:625

References field_entry::color(), map::field_at(), fold_and_print(), get_fire_fuel_string(), catacurses::getmaxx(), map::has_flag(), line(), m, mvwprintz(), field_entry::name(), t_pit, t_pit_shallow, map::ter(), and TFLAG_FIRE_CONTAINER.

Referenced by print_all_tile_info().

◆ print_graffiti_info()

void game::print_graffiti_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6112 of file game.cpp.

6115{
6116 if( line > last_line ) {
6117 return;
6118 }
6119
6120 const int max_width = getmaxx( w_look ) - column - 2;
6121 if( m.has_graffiti_at( lp ) ) {
6122 fold_and_print( w_look, point( column, ++line ), max_width, c_light_gray,
6123 m.ter( lp ) == t_grave_new ? _( "Graffiti: %s" ) : _( "Inscription: %s" ),
6124 m.graffiti_at( lp ) );
6125 }
6126}
ter_id t_grave_new
Definition: mapdata.cpp:625

References _, c_light_gray, fold_and_print(), catacurses::getmaxx(), map::graffiti_at(), map::has_graffiti_at(), line(), m, t_grave_new, and map::ter().

Referenced by print_all_tile_info().

◆ print_items_info()

void game::print_items_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6075 of file game.cpp.

6078{
6079 if( !m.sees_some_items( lp, u ) ) {
6080 return;
6081 } else if( m.has_flag( "CONTAINER", lp ) && !m.could_see_items( lp, u ) ) {
6082 mvwprintw( w_look, point( column, ++line ), _( "You cannot see what is inside of it." ) );
6083 } else if( u.has_effect( effect_blind ) || u.worn_with_flag( "BLIND" ) ) {
6084 mvwprintz( w_look, point( column, ++line ), c_yellow,
6085 _( "There's something there, but you can't see what it is." ) );
6086 return;
6087 } else {
6088 std::map<std::string, int> item_names;
6089 for( auto &item : m.i_at( lp ) ) {
6090 ++item_names[item.tname()];
6091 }
6092
6093 const int max_width = getmaxx( w_look ) - column - 1;
6094 for( auto it = item_names.begin(); it != item_names.end(); ++it ) {
6095 // last line but not last item
6096 if( line + 1 >= last_line && std::next( it ) != item_names.end() ) {
6097 mvwprintz( w_look, point( column, ++line ), c_yellow, _( "More items here…" ) );
6098 break;
6099 }
6100
6101 if( it->second > 1 ) {
6102 trim_and_print( w_look, point( column, ++line ), max_width, c_white,
6103 pgettext( "%s is the name of the item. %d is the quantity of that item.", "%s [%d]" ),
6104 it->first.c_str(), it->second );
6105 } else {
6106 trim_and_print( w_look, point( column, ++line ), max_width, c_white, it->first );
6107 }
6108 }
6109 }
6110}
bool could_see_items(const tripoint &p, const Creature &who) const
Check if the creature could see items at p if there were any items.
Definition: map.cpp:4736
static const efftype_id effect_blind("blind")

References _, c_white, c_yellow, map::could_see_items(), effect_blind, catacurses::getmaxx(), Creature::has_effect(), map::has_flag(), map::i_at(), line(), m, catacurses::mvwprintw(), mvwprintz(), pgettext(), map::sees_some_items(), item::tname(), trim_and_print(), u, and Character::worn_with_flag().

Referenced by print_all_tile_info().

◆ print_terrain_info()

void game::print_terrain_info ( const tripoint lp,
const catacurses::window w_look,
const std::string &  area_name,
int  column,
int &  line 
)
private

Definition at line 5947 of file game.cpp.

5950{
5951 const int max_width = getmaxx( w_look ) - column - 1;
5952 int lines;
5953
5954 const auto fmt_tile_info = []( const tripoint & lp ) {
5955 map &here = get_map();
5956 std::string ret;
5957 if( debug_mode ) {
5958 ret = string_format( "%s %s", lp.to_string(), here.ter( lp )->id );
5959 if( here.has_furn( lp ) ) {
5960 ret += "; " + here.furn( lp )->id.str();
5961 }
5962 } else {
5963 ret = here.tername( lp );
5964 if( here.has_furn( lp ) ) {
5965 ret += "; " + here.furnname( lp );
5966 }
5967 }
5968 return ret;
5969 };
5970
5971 std::string tile = string_format( "(%s) %s", area_name, fmt_tile_info( lp ) );
5972
5973 if( m.impassable( lp ) ) {
5974 lines = fold_and_print( w_look, point( column, line ), max_width, c_light_gray,
5975 _( "%s; Impassable" ),
5976 tile );
5977 } else {
5978 lines = fold_and_print( w_look, point( column, line ), max_width, c_light_gray,
5979 _( "%s; Movement cost %d" ),
5980 tile, m.move_cost( lp ) * 50 );
5981
5982 const auto ll = get_light_level( std::max( 1.0,
5983 LIGHT_AMBIENT_LIT - m.ambient_light_at( lp ) + 1.0 ) );
5984 mvwprintw( w_look, point( column, ++lines ), _( "Lighting: " ) );
5985 wprintz( w_look, ll.second, ll.first );
5986 }
5987
5988 std::string signage = m.get_signage( lp );
5989 if( !signage.empty() ) {
5990 trim_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
5991 // NOLINTNEXTLINE(cata-text-style): the question mark does not end a sentence
5992 u.has_trait( trait_ILLITERATE ) ? _( "Sign: ???" ) : _( "Sign: %s" ), signage );
5993 }
5994
5995 if( m.has_zlevels() && lp.z > -OVERMAP_DEPTH && !m.has_floor( lp ) ) {
5996 // Print info about stuff below
5997 tripoint below( lp.xy(), lp.z - 1 );
5998 std::string tile_below = fmt_tile_info( below );
5999
6000 if( !m.has_floor_or_support( lp ) ) {
6001 fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
6002 _( "Below: %s; No support" ),
6003 tile_below );
6004 } else {
6005 fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
6006 _( "Below: %s; Walkable" ),
6007 tile_below );
6008 }
6009 }
6010
6011 int map_features = fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
6012 m.features( lp ) );
6013 fold_and_print( w_look, point( column, ++lines ), max_width, c_light_gray, _( "Coverage: %d%%" ),
6014 m.coverage( lp ) );
6015 if( line < lines ) {
6016 line = lines + map_features - 1;
6017 }
6018}
Manage and cache data about a part of the map.
Definition: map.h:389
bool has_floor_or_support(const tripoint &p) const
Definition: map.cpp:2039
float ambient_light_at(const tripoint &p) const
Definition: lightmap.cpp:617
std::string features(const tripoint &p)
Definition: map.cpp:1714
int coverage(const tripoint &p) const
Returns coverage value of the tile.
Definition: map.cpp:6244
const std::string & str() const
Returns the identifier as plain std::string.
Definition: string_id.h:255
static constexpr float LIGHT_AMBIENT_LIT
Definition: lightmap.h:18
std::pair< std::string, nc_color > get_light_level(const float light)
Definition: output.cpp:1621
furn_str_id id
Definition: mapdata.h:496
ter_str_id id
Definition: mapdata.h:461

References _, map::ambient_light_at(), c_dark_gray, c_light_gray, map::coverage(), debug_mode, map::features(), fold_and_print(), map::furn(), map::furnname(), get_light_level(), get_map, map::get_signage(), catacurses::getmaxx(), map::has_floor(), map::has_floor_or_support(), map::has_furn(), Character::has_trait(), map::has_zlevels(), ter_t::id, furn_t::id, map::impassable(), LIGHT_AMBIENT_LIT, line(), m, map::move_cost(), catacurses::mvwprintw(), OVERMAP_DEPTH, cata::hash64_detail::ret, string_id< T >::str(), string_format(), map::ter(), map::tername(), tripoint::to_string(), trait_ILLITERATE, trim_and_print(), u, wprintz(), tripoint::xy(), and tripoint::z.

Referenced by print_all_tile_info().

◆ print_trap_info()

void game::print_trap_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line 
)
private

Definition at line 6038 of file game.cpp.

6040{
6041 const trap &tr = m.tr_at( lp );
6042 if( tr.can_see( lp, u ) ) {
6043 partial_con *pc = m.partial_con_at( lp );
6044 std::string tr_name;
6045 if( pc && tr.loadid == tr_unfinished_construction ) {
6046 const construction &built = pc->id.obj();
6047 tr_name = string_format( _( "Unfinished task: %s, %d%% complete" ), built.group->name(),
6048 pc->counter / 100000 );
6049 } else {
6050 tr_name = tr.name();
6051 }
6052
6053 mvwprintz( w_look, point( column, ++line ), tr.color, tr_name );
6054 }
6055}
partial_con * partial_con_at(const tripoint &p)
Definition: map.cpp:5141
static const trap_str_id tr_unfinished_construction("tr_unfinished_construction")
std::string name() const
construction_group_str_id group
Definition: construction.h:50
construction_id id
nc_color color
Definition: trap.h:93

References _, trap::can_see(), trap::color, partial_con::counter, construction::group, partial_con::id, line(), trap::loadid, m, mvwprintz(), construction_group::name(), trap::name(), int_id< T >::obj(), map::partial_con_at(), string_format(), map::tr_at(), tr_unfinished_construction, and u.

Referenced by print_all_tile_info().

◆ print_vehicle_info()

void game::print_vehicle_info ( const vehicle veh,
int  veh_part,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6066 of file game.cpp.

6068{
6069 if( veh ) {
6070 mvwprintw( w_look, point( column, ++line ), _( "There is a %s there. Parts:" ), veh->name );
6071 line = veh->print_part_list( w_look, ++line, last_line, getmaxx( w_look ), veh_part );
6072 }
6073}
int print_part_list(const catacurses::window &win, int y1, int max_y, int width, int p, int hl=-1, bool detail=false) const
Prints a list of all parts to the screen inside of a boxed window, possibly highlighting a selected o...

References _, catacurses::getmaxx(), line(), catacurses::mvwprintw(), vehicle::name, and vehicle::print_part_list().

Referenced by print_all_tile_info().

◆ print_visibility_info()

void game::print_visibility_info ( const catacurses::window w_look,
int  column,
int &  line,
visibility_type  visibility 
)
private

Definition at line 5918 of file game.cpp.

5920{
5921 const char *visibility_message = nullptr;
5922 switch( visibility ) {
5923 case VIS_CLEAR:
5924 visibility_message = _( "Clearly visible." );
5925 break;
5926 case VIS_BOOMER:
5927 visibility_message = _( "A bright pink blur." );
5928 break;
5929 case VIS_BOOMER_DARK:
5930 visibility_message = _( "A pink blur." );
5931 break;
5932 case VIS_DARK:
5933 visibility_message = _( "Darkness." );
5934 break;
5935 case VIS_LIT:
5936 visibility_message = _( "Bright light." );
5937 break;
5938 case VIS_HIDDEN:
5939 visibility_message = _( "Unseen." );
5940 break;
5941 }
5942
5943 mvwprintw( w_look, point( line, column ), visibility_message );
5944 line += 2;
5945}

References _, line(), catacurses::mvwprintw(), VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, and VIS_LIT.

Referenced by print_all_tile_info().

◆ process_activity()

void game::process_activity ( )
private

Definition at line 1759 of file game.cpp.

1760{
1761 if( !u.activity ) {
1762 return;
1763 }
1764
1765 while( u.moves > 0 && u.activity ) {
1766 u.activity.do_turn( u );
1767 }
1768}
void do_turn(player &p)
Performs the activity for a single turn.

References Character::activity, player_activity::do_turn(), Creature::moves, and u.

Referenced by do_turn().

◆ process_artifact()

void game::process_artifact ( item it,
player p 
)

Definition at line 11425 of file game.cpp.

11426{
11427 const bool worn = p.is_worn( it );
11428 const bool wielded = ( &it == &p.weapon );
11429 std::vector<art_effect_passive> effects = it.type->artifact->effects_carried;
11430 if( worn ) {
11431 const std::vector<art_effect_passive> &ew = it.type->artifact->effects_worn;
11432 effects.insert( effects.end(), ew.begin(), ew.end() );
11433 }
11434 if( wielded ) {
11435 const std::vector<art_effect_passive> &ew = it.type->artifact->effects_wielded;
11436 effects.insert( effects.end(), ew.begin(), ew.end() );
11437 }
11438
11439 if( it.is_tool() ) {
11440 // Recharge it if necessary
11441 if( it.ammo_remaining() < it.ammo_capacity() && calendar::once_every( 1_minutes ) ) {
11442 //Before incrementing charge, check that any extra requirements are met
11443 if( check_art_charge_req( it ) ) {
11444 switch( it.type->artifact->charge_type ) {
11445 case ARTC_NULL:
11446 case NUM_ARTCS:
11447 break; // dummy entries
11448 case ARTC_TIME:
11449 // Once per hour
11450 if( calendar::once_every( 1_hours ) ) {
11451 it.charges++;
11452 }
11453 break;
11454 case ARTC_SOLAR:
11455 if( calendar::once_every( 10_minutes ) &&
11456 is_in_sunlight( p.pos() ) ) {
11457 it.charges++;
11458 }
11459 break;
11460 // Artifacts can inflict pain even on Deadened folks.
11461 // Some weird Lovecraftian thing. ;P
11462 // (So DON'T route them through mod_pain!)
11463 case ARTC_PAIN:
11464 if( calendar::once_every( 1_minutes ) ) {
11465 add_msg( m_bad, _( "You suddenly feel sharp pain for no reason." ) );
11466 p.mod_pain_noresist( 3 * rng( 1, 3 ) );
11467 it.charges++;
11468 }
11469 break;
11470 case ARTC_HP:
11471 if( calendar::once_every( 1_minutes ) ) {
11472 add_msg( m_bad, _( "You feel your body decaying." ) );
11473 p.hurtall( 1, nullptr );
11474 it.charges++;
11475 }
11476 break;
11477 case ARTC_FATIGUE:
11478 if( calendar::once_every( 1_minutes ) ) {
11479 add_msg( m_bad, _( "You feel fatigue seeping into your body." ) );
11480 u.mod_fatigue( 3 * rng( 1, 3 ) );
11481 u.mod_stamina( -90 * rng( 1, 3 ) * rng( 1, 3 ) * rng( 2, 3 ) );
11482 it.charges++;
11483 }
11484 break;
11485 // Portals are energetic enough to charge the item.
11486 // Tears in reality are consumed too, but can't charge it.
11487 case ARTC_PORTAL:
11488 for( const tripoint &dest : m.points_in_radius( p.pos(), 1 ) ) {
11489 m.remove_field( dest, fd_fatigue );
11490 if( m.tr_at( dest ).loadid == tr_portal ) {
11491 add_msg( m_good, _( "The portal collapses!" ) );
11492 m.remove_trap( dest );
11493 it.charges++;
11494 break;
11495 }
11496 }
11497 break;
11498 }
11499 }
11500 }
11501 }
11502
11503 for( const art_effect_passive &i : effects ) {
11504 switch( i ) {
11505 case AEP_STR_UP:
11506 p.mod_str_bonus( +4 );
11507 break;
11508 case AEP_DEX_UP:
11509 p.mod_dex_bonus( +4 );
11510 break;
11511 case AEP_PER_UP:
11512 p.mod_per_bonus( +4 );
11513 break;
11514 case AEP_INT_UP:
11515 p.mod_int_bonus( +4 );
11516 break;
11517 case AEP_ALL_UP:
11518 p.mod_str_bonus( +2 );
11519 p.mod_dex_bonus( +2 );
11520 p.mod_per_bonus( +2 );
11521 p.mod_int_bonus( +2 );
11522 break;
11523 case AEP_SPEED_UP:
11524 // Handled in player::current_speed()
11525 break;
11526
11527 case AEP_PBLUE:
11528 if( p.get_rad() > 0 ) {
11529 p.mod_rad( -1 );
11530 }
11531 break;
11532
11533 case AEP_SMOKE:
11534 if( one_in( 10 ) ) {
11535 tripoint pt( p.posx() + rng( -1, 1 ),
11536 p.posy() + rng( -1, 1 ),
11537 p.posz() );
11538 m.add_field( pt, fd_smoke, rng( 1, 3 ) );
11539 }
11540 break;
11541
11542 case AEP_SNAKES:
11543 break; // Handled in player::hit()
11544
11545 case AEP_EXTINGUISH:
11546 for( const tripoint &dest : m.points_in_radius( p.pos(), 1 ) ) {
11547 m.mod_field_age( dest, fd_fire, -1_turns );
11548 }
11549 break;
11550
11551 case AEP_FUN:
11552 //Bonus fluctuates, wavering between 0 and 30-ish - usually around 12
11553 p.add_morale( MORALE_FEELING_GOOD, rng( 1, 2 ) * rng( 2, 3 ), 0, 3_turns, 0_turns, false );
11554 break;
11555
11556 case AEP_HUNGER:
11557 if( one_in( 100 ) ) {
11558 p.mod_stored_kcal( -10 );
11559 }
11560 break;
11561
11562 case AEP_THIRST:
11563 if( one_in( 120 ) ) {
11564 p.mod_thirst( 1 );
11565 }
11566 break;
11567
11568 case AEP_EVIL:
11569 if( one_in( 150 ) ) { // Once every 15 minutes, on average
11570 p.add_effect( effect_evil, 30_minutes );
11571 if( it.is_armor() ) {
11572 if( !worn ) {
11573 add_msg( _( "You have an urge to wear the %s." ),
11574 it.tname() );
11575 }
11576 } else if( !wielded ) {
11577 add_msg( _( "You have an urge to wield the %s." ),
11578 it.tname() );
11579 }
11580 }
11581 break;
11582
11583 case AEP_SCHIZO:
11584 break; // Handled in player::suffer()
11585
11586 case AEP_RADIOACTIVE:
11587 if( one_in( 4 ) ) {
11588 p.irradiate( 1.0f );
11589 }
11590 break;
11591
11592 case AEP_STR_DOWN:
11593 p.mod_str_bonus( -3 );
11594 break;
11595
11596 case AEP_DEX_DOWN:
11597 p.mod_dex_bonus( -3 );
11598 break;
11599
11600 case AEP_PER_DOWN:
11601 p.mod_per_bonus( -3 );
11602 break;
11603
11604 case AEP_INT_DOWN:
11605 p.mod_int_bonus( -3 );
11606 break;
11607
11608 case AEP_ALL_DOWN:
11609 p.mod_str_bonus( -2 );
11610 p.mod_dex_bonus( -2 );
11611 p.mod_per_bonus( -2 );
11612 p.mod_int_bonus( -2 );
11613 break;
11614
11615 case AEP_SPEED_DOWN:
11616 break; // Handled in player::current_speed()
11617
11618 default:
11619 //Suppress warnings
11620 break;
11621 }
11622 }
11623 // Recalculate, as it might have changed (by mod_*_bonus above)
11624 p.str_cur = p.get_str();
11625 p.int_cur = p.get_int();
11626 p.dex_cur = p.get_dex();
11627 p.per_cur = p.get_per();
11628}
@ ARTC_PORTAL
Definition: artifact.h:69
@ ARTC_FATIGUE
Definition: artifact.h:68
@ ARTC_NULL
Definition: artifact.h:63
@ ARTC_SOLAR
Definition: artifact.h:65
@ NUM_ARTCS
Definition: artifact.h:70
@ ARTC_HP
Definition: artifact.h:67
@ ARTC_TIME
Definition: artifact.h:64
@ ARTC_PAIN
Definition: artifact.h:66
virtual void mod_per_bonus(int nper)
Definition: character.cpp:4184
virtual void mod_dex_bonus(int ndex)
Definition: character.cpp:4179
int str_cur
Definition: character.h:247
void mod_rad(int mod)
Definition: character.cpp:7186
virtual int get_dex() const
Definition: character.cpp:4068
virtual void mod_stored_kcal(int nkcal)
Modifiers for need values exclusive to characters.
Definition: character.cpp:4299
bool is_worn(const item &thing) const
Definition: character.h:1082
virtual int get_int() const
Definition: character.cpp:4076
virtual void mod_fatigue(int nfatigue)
Definition: character.cpp:4430
virtual void mod_str_bonus(int nstr)
Definition: character.cpp:4174
int int_cur
Definition: character.h:249
int get_rad() const
Definition: character.cpp:7176
void add_morale(const morale_type &type, int bonus, int max_bonus=0, const time_duration &duration=1_hours, const time_duration &decay_start=30_minutes, bool capped=false, const itype *item_type=nullptr)
Definition: character.cpp:9096
virtual int get_per() const
Definition: character.cpp:4072
void mod_stamina(int mod)
Definition: character.cpp:7213
void hurtall(int dam, Creature *source, bool disturb=true)
Hurts all body parts for dam, no armor reduction.
Definition: character.cpp:8666
bool irradiate(float rads, bool bypass=false)
Handles mitigation and application of radiation.
Definition: suffer.cpp:1531
virtual void mod_int_bonus(int nint)
Definition: character.cpp:4189
virtual void mod_pain_noresist(int npain)
Definition: creature.cpp:1352
bool is_in_sunlight(const tripoint &p)
Returns true if p is outdoors and it is sunny.
Definition: game.cpp:4979
int ammo_remaining() const
Quantity of ammunition currently loaded in tool, gun or auxiliary gunmod.
Definition: item.cpp:7247
bool is_tool() const
Definition: item.cpp:6824
int ammo_capacity() const
Maximum quantity of ammunition loadable for tool, gun or auxiliary gunmod.
Definition: item.cpp:7274
int charges
Definition: item.h:2196
bool is_armor() const
Definition: item.cpp:6575
const itype * type
Definition: item.h:2157
bool add_field(const tripoint &p, const field_type_id &type_id, int intensity=INT_MAX, const time_duration &age=0_turns, bool hit_player=true)
Add field entry at point, or set intensity if present.
Definition: map.cpp:5396
time_duration mod_field_age(const tripoint &p, const field_type_id &type, const time_duration &offset)
Increment/decrement age of field entry at point.
Definition: map.cpp:5316
void remove_trap(const tripoint &p)
Definition: map.cpp:5261
art_effect_passive
Definition: enums.h:99
@ AEP_EXTINGUISH
Definition: enums.h:114
field_type_id fd_smoke
Definition: field_type.cpp:346
field_type_id fd_fatigue
Definition: field_type.cpp:354
static const efftype_id effect_evil("evil")
static const trap_str_id tr_portal("tr_portal")
const morale_type MORALE_FEELING_GOOD("morale_feeling_good")
cata::value_ptr< islot_artifact > artifact
Definition: itype.h:866

References _, Creature::add_effect(), map::add_field(), Character::add_morale(), add_msg(), AEP_ALL_DOWN, AEP_ALL_UP, AEP_DEX_DOWN, AEP_DEX_UP, AEP_EVIL, AEP_EXTINGUISH, AEP_FUN, AEP_HUNGER, AEP_INT_DOWN, AEP_INT_UP, AEP_PBLUE, AEP_PER_DOWN, AEP_PER_UP, AEP_RADIOACTIVE, AEP_SCHIZO, AEP_SMOKE, AEP_SNAKES, AEP_SPEED_DOWN, AEP_SPEED_UP, AEP_STR_DOWN, AEP_STR_UP, AEP_THIRST, item::ammo_capacity(), item::ammo_remaining(), ARTC_FATIGUE, ARTC_HP, ARTC_NULL, ARTC_PAIN, ARTC_PORTAL, ARTC_SOLAR, ARTC_TIME, itype::artifact, item::charges, check_art_charge_req(), Character::dex_cur, effect_evil, fd_fatigue, fd_fire, fd_smoke, Character::get_dex(), Character::get_int(), Character::get_per(), Character::get_rad(), Character::get_str(), Character::hurtall(), Character::int_cur, Character::irradiate(), item::is_armor(), is_in_sunlight(), item::is_tool(), Character::is_worn(), trap::loadid, m, m_bad, m_good, Character::mod_dex_bonus(), Character::mod_fatigue(), map::mod_field_age(), Character::mod_int_bonus(), Creature::mod_pain_noresist(), Character::mod_per_bonus(), Character::mod_rad(), Character::mod_stamina(), Character::mod_stored_kcal(), Character::mod_str_bonus(), Character::mod_thirst(), MORALE_FEELING_GOOD, NUM_ARTCS, calendar::once_every(), one_in(), Character::per_cur, map::points_in_radius(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), map::remove_field(), map::remove_trap(), rng(), Character::str_cur, item::tname(), map::tr_at(), tr_portal, item::type, u, and Character::weapon.

◆ process_voluntary_act_interrupt()

void game::process_voluntary_act_interrupt ( )
private

Definition at line 1719 of file game.cpp.

1720{
1721 if( u.has_effect( effect_sleep ) ) {
1722 // Can't interrupt
1723 return;
1724 }
1725
1726 bool has_activity = u.activity && u.activity.moves_left > 0;
1727 bool is_travelling = u.has_destination() && !u.omt_path.empty();
1728
1729 if( !has_activity && !is_travelling ) {
1730 // Nohing to interrupt
1731 return;
1732 }
1733
1734 // Key poll may be quite expensive, so limit it to 10 times per second.
1735 static auto last_poll = std::chrono::steady_clock::now();
1736 auto now = std::chrono::steady_clock::now();
1737 int64_t difference = std::chrono::duration_cast<std::chrono::milliseconds>
1738 ( now - last_poll ).count();
1739
1740 if( difference > 100 ) {
1742 last_poll = now;
1743 }
1744
1745 // If player is performing a task and a monster is dangerously close, warn them
1746 // regardless of previous safemode warnings.
1747 // Distraction Manager can change this.
1748 if( has_activity && !u.has_activity( activity_id( "ACT_AIM" ) ) &&
1750 Creature *hostile_critter = is_hostile_very_close();
1751 if( hostile_critter != nullptr ) {
1753 string_format( _( "The %s is dangerously close!" ),
1754 hostile_critter->get_name() ) );
1755 }
1756 }
1757}
bool has_activity(const activity_id &type) const
Check if player currently has a given activity.
Definition: character.cpp:9227
virtual std::string get_name() const =0
void handle_key_blocking_activity()
Definition: game.cpp:2080
int moves_left
The number of moves remaining in this activity before it is complete.

References _, Character::activity, cancel_activity_or_ignore_query(), effect_sleep, Creature::get_name(), handle_key_blocking_activity(), Character::has_activity(), Character::has_destination(), Creature::has_effect(), hostile_spotted_near, player_activity::is_distraction_ignored(), is_hostile_very_close(), player_activity::moves_left, Character::omt_path, string_format(), and u.

Referenced by do_turn().

◆ prompt_dangerous_tile()

bool game::prompt_dangerous_tile ( const tripoint dest_loc) const

Definition at line 8802 of file game.cpp.

8803{
8804 std::vector<std::string> harmful_stuff = get_dangerous_tile( dest_loc );
8805
8806 if( !harmful_stuff.empty() &&
8807 !query_yn( _( "Really step into %s?" ), enumerate_as_string( harmful_stuff ) ) ) {
8808 return false;
8809 }
8810 if( !harmful_stuff.empty() && u.is_mounted() &&
8811 m.tr_at( dest_loc ).loadid == tr_ledge ) {
8812 add_msg( m_warning, _( "Your %s refuses to move over that ledge!" ),
8813 u.mounted_creature->get_name() );
8814 return false;
8815 }
8816 return true;
8817}

References _, add_msg(), enumerate_as_string(), get_dangerous_tile(), Character::is_mounted(), trap::loadid, m, m_warning, Character::mounted_creature, query_yn(), map::tr_at(), tr_ledge, and u.

Referenced by npc_menu(), and walk_move().

◆ quickload()

void game::quickload ( )
private

Definition at line 11393 of file game.cpp.

11394{
11395 const WORLDPTR active_world = world_generator->active_world;
11396 if( active_world == nullptr ) {
11397 return;
11398 }
11399
11400 if( active_world->save_exists( save_t::from_player_name( u.name ) ) ) {
11401 if( moves_since_last_save != 0 ) { // See if we need to reload anything
11402 MAPBUFFER.reset();
11404 try {
11405 setup();
11406 } catch( const std::exception &err ) {
11407 debugmsg( "Error: %s", err.what() );
11408 }
11410 }
11411 } else {
11412 popup_getkey( _( "No saves for %s yet." ), u.name );
11413 }
11414}
bool load(const std::string &world)
Attempt to load first valid save (if any) in world.
Definition: game.cpp:2615
void setup()
Definition: game.cpp:574
static save_t from_player_name(const std::string &name)
int popup_getkey(const char *const mes, Args &&... args)
Definition: output.h:500
bool save_exists(const save_t &name) const

References _, overmapbuffer::clear(), debugmsg, save_t::from_player_name(), load(), MAPBUFFER, moves_since_last_save, Character::name, overmap_buffer, popup_getkey(), mapbuffer::reset(), WORLD::save_exists(), setup(), u, and world_generator.

Referenced by handle_action().

◆ quicksave()

void game::quicksave ( )

Definition at line 11371 of file game.cpp.

11372{
11373 //Don't autosave if the player hasn't done anything since the last autosave/quicksave,
11374 if( !moves_since_last_save ) {
11375 return;
11376 }
11377 add_msg( m_info, _( "Saving game, this may take a while" ) );
11378
11380 popup.message( "%s", _( "Saving game, this may take a while" ) );
11383
11384 time_t now = time( nullptr ); //timestamp for start of saving procedure
11385
11386 //perform save
11387 save();
11388 //Now reset counters for autosaving, so we don't immediately autosave after a quicksave or autosave.
11390 last_save_timestamp = now;
11391}

References _, add_msg(), last_save_timestamp, m_info, moves_since_last_save, popup(), ui_manager::redraw(), refresh_display(), and save().

Referenced by autosave(), and handle_action().

◆ reenter_fullscreen()

void game::reenter_fullscreen ( )

Definition at line 562 of file game.cpp.

563{
564 if( was_fullscreen ) {
565 if( !fullscreen ) {
567 }
568 }
569}

References fullscreen, toggle_fullscreen(), and was_fullscreen.

Referenced by list_items_monsters(), and look_around().

◆ reload_npcs()

void game::reload_npcs ( )

Unloads, then loads the NPCs.

Definition at line 976 of file game.cpp.

977{
978 // TODO: Make it not invoke the "on_unload" command for the NPCs that will be loaded anyway
979 // and not invoke "on_load" for those NPCs that avoided unloading this way.
980 unload_npcs();
981 load_npcs();
982}

References load_npcs(), and unload_npcs().

Referenced by load(), overmap_npc_move(), vertical_move(), and vertical_shift().

◆ reload_tileset()

void game::reload_tileset ( )

Definition at line 526 of file game.cpp.

527{
528#if defined(TILES)
529 // Disable UIs below to avoid accessing the tile context during loading.
531 try {
532 tilecontext->reinit();
533 std::vector<mod_id> dummy;
534 tilecontext->load_tileset(
535 get_option<std::string>( "TILES" ),
536 world_generator->active_world ? world_generator->active_world->active_mod_order : dummy,
537 /*precheck=*/false,
538 /*force=*/true,
539 /*pump_events=*/true
540 );
541 tilecontext->do_tile_loading_report();
542 } catch( const std::exception &err ) {
543 popup( _( "Loading the tileset failed: %s" ), err.what() );
544 }
545 g->reset_zoom();
546 g->mark_main_ui_adaptor_resize();
547#endif // TILES
548}

References _, g, popup(), and world_generator.

Referenced by handle_action().

◆ remoteveh()

vehicle * game::remoteveh ( )

Returns the current remotely controlled vehicle.

Definition at line 2356 of file game.cpp.

2357{
2359 return remoteveh_cache;
2360 }
2362 std::stringstream remote_veh_string( u.get_value( "remote_controlling_vehicle" ) );
2363 if( remote_veh_string.str().empty() ||
2365 remoteveh_cache = nullptr;
2366 } else {
2367 tripoint vp;
2368 remote_veh_string >> vp.x >> vp.y >> vp.z;
2369 vehicle *veh = veh_pointer_or_null( m.veh_at( vp ) );
2370 if( veh && veh->fuel_left( itype_battery, true ) > 0 ) {
2371 remoteveh_cache = veh;
2372 } else {
2373 remoteveh_cache = nullptr;
2374 }
2375 }
2376 return remoteveh_cache;
2377}
vehicle * remoteveh_cache
Definition: game.h:1071
int fuel_left(const itype_id &ftype, bool recurse=false) const
Definition: vehicle.cpp:3359
static const bionic_id bio_remote("bio_remote")
static const itype_id itype_remotevehcontrol("remotevehcontrol")
static const itype_id itype_battery("battery")

References bio_remote, vehicle::fuel_left(), Creature::get_value(), Character::has_active_bionic(), Character::has_active_item(), itype_battery, itype_remotevehcontrol, m, remoteveh_cache, remoteveh_cache_time, calendar::turn, u, map::veh_at(), veh_pointer_or_null(), tripoint::x, tripoint::y, and tripoint::z.

Referenced by control_vehicle(), and handle_action().

◆ remove_npc_follower()

void game::remove_npc_follower ( const character_id id)

Remove follower id from follower set.

Definition at line 1989 of file game.cpp.

1990{
1991 follower_ids.erase( id );
1992 u.follower_ids.erase( id );
1993}

References follower_ids, player::follower_ids, and u.

Referenced by cleanup_dead().

◆ remove_zombie()

void game::remove_zombie ( const monster critter)

Definition at line 4858 of file game.cpp.

4859{
4860 critter_tracker->remove( critter );
4861}

References critter_tracker.

Referenced by despawn_monster(), disable_robot(), start_game(), and vertical_move().

◆ replace_stair_monsters()

void game::replace_stair_monsters ( )
private

Definition at line 10891 of file game.cpp.

10892{
10893 for( auto &elem : coming_to_stairs ) {
10894 elem.staircount = 0;
10895 const tripoint pnt( elem.pos().xy(), get_levz() );
10896 place_critter_around( make_shared_fast<monster>( elem ), pnt, 10 );
10897 }
10898
10899 coming_to_stairs.clear();
10900}
std::vector< monster > coming_to_stairs
Definition: game.h:1009

References coming_to_stairs, get_levz(), and place_critter_around().

◆ reset_item_list_state()

void game::reset_item_list_state ( const catacurses::window window,
int  height,
bool  bRadiusSort 
)
private

Definition at line 7267 of file game.cpp.

7268{
7269 const int width = getmaxx( window );
7270 for( int i = 1; i < TERMX; i++ ) {
7271 if( i < width ) {
7272 mvwputch( window, point( i, 0 ), c_light_gray, LINE_OXOX ); // -
7273 mvwputch( window, point( i, TERMY - height - 1 ), c_light_gray,
7274 LINE_OXOX ); // -
7275 }
7276
7277 if( i < TERMY - height ) {
7278 mvwputch( window, point( 0, i ), c_light_gray, LINE_XOXO ); // |
7279 mvwputch( window, point( width - 1, i ), c_light_gray, LINE_XOXO ); // |
7280 }
7281 }
7282
7283 mvwputch( window, point_zero, c_light_gray, LINE_OXXO ); // |^
7284 mvwputch( window, point( width - 1, 0 ), c_light_gray, LINE_OOXX ); // ^|
7285
7286 mvwputch( window, point( 0, TERMY - height - 1 ), c_light_gray,
7287 LINE_XXXO ); // |-
7288 mvwputch( window, point( width - 1, TERMY - height - 1 ), c_light_gray,
7289 LINE_XOXX ); // -|
7290
7291 mvwprintz( window, point( 2, 0 ), c_light_green, "<Tab> " );
7292 wprintz( window, c_white, _( "Items" ) );
7293
7294 std::string sSort;
7295 if( bRadiusSort ) {
7296 //~ Sort type: distance.
7297 sSort = _( "<s>ort: dist" );
7298 } else {
7299 //~ Sort type: category.
7300 sSort = _( "<s>ort: cat" );
7301 }
7302
7303 int letters = utf8_width( sSort );
7304
7305 shortcut_print( window, point( getmaxx( window ) - letters, 0 ), c_white, c_light_green, sSort );
7306
7307 std::vector<std::string> tokens;
7308 if( !sFilter.empty() ) {
7309 tokens.emplace_back( _( "<R>eset" ) );
7310 }
7311
7312 tokens.emplace_back( _( "<E>xamine" ) );
7313 tokens.emplace_back( _( "<C>ompare" ) );
7314 tokens.emplace_back( _( "<F>ilter" ) );
7315 tokens.emplace_back( _( "<+/->Priority" ) );
7316
7317 int gaps = tokens.size() + 1;
7318 letters = 0;
7319 int n = tokens.size();
7320 for( int i = 0; i < n; i++ ) {
7321 letters += utf8_width( tokens[i] ) - 2; //length ignores < >
7322 }
7323
7324 int usedwidth = letters;
7325 const int gap_spaces = ( width - usedwidth ) / gaps;
7326 usedwidth += gap_spaces * gaps;
7327 point pos( gap_spaces + ( width - usedwidth ) / 2, TERMY - height - 1 );
7328
7329 for( int i = 0; i < n; i++ ) {
7330 pos.x += shortcut_print( window, pos, c_white, c_light_green,
7331 tokens[i] ) + gap_spaces;
7332 }
7333}
#define LINE_OOXX
Definition: output.h:43
#define LINE_OXXO
Definition: output.h:42

References _, c_light_gray, c_light_green, c_white, catacurses::getmaxx(), LINE_OOXX, LINE_OXOX, LINE_OXXO, LINE_XOXO, LINE_XOXX, LINE_XXXO, mvwprintz(), mvwputch(), point_zero, sFilter, shortcut_print(), TERMX, TERMY, utf8_width(), wprintz(), and point::x.

Referenced by list_items().

◆ reset_light_level()

void game::reset_light_level ( )

Definition at line 3717 of file game.cpp.

3718{
3719 for( float &lev : latest_lightlevels ) {
3720 lev = -std::numeric_limits<float>::max();
3721 }
3722}

References latest_lightlevels.

Referenced by do_turn(), and game().

◆ reset_npc_dispositions()

void game::reset_npc_dispositions ( )
private

Definition at line 2792 of file game.cpp.

2793{
2794 for( auto elem : follower_ids ) {
2795 shared_ptr_fast<npc> npc_to_get = overmap_buffer.find_npc( elem );
2796 if( !npc_to_get ) {
2797 continue;
2798 }
2799 npc *npc_to_add = npc_to_get.get();
2800 npc_to_add->chatbin.missions.clear();
2801 npc_to_add->chatbin.missions_assigned.clear();
2802 npc_to_add->mission = NPC_MISSION_NULL;
2803 npc_to_add->chatbin.mission_selected = nullptr;
2804 npc_to_add->set_attitude( NPCATT_NULL );
2805 npc_to_add->op_of_u.anger = 0;
2806 npc_to_add->op_of_u.fear = 0;
2807 npc_to_add->op_of_u.trust = 0;
2808 npc_to_add->op_of_u.value = 0;
2809 npc_to_add->op_of_u.owed = 0;
2810 npc_to_add->set_fac( faction_id( "no_faction" ) );
2812 npc_to_add->global_omt_location(),
2813 npc_to_add->getID() ) );
2814
2815 }
2816
2817}
void set_attitude(npc_attitude new_attitude)
Definition: npc.cpp:3144
npc_chatbin chatbin
Definition: npc.h:1329
void add_new_mission(mission *miss)
See npc_chatbin::add_new_mission.
Definition: npc.cpp:2640
npc_opinion op_of_u
Definition: npc.h:1328
void set_fac(const faction_id &id)
Definition: npc.cpp:466
std::vector< mission * > missions_assigned
Mission that have been assigned by this NPC to a player character.
Definition: npc.h:752
mission * mission_selected
The mission (if any) that we talk about right now.
Definition: npc.h:757
std::vector< mission * > missions
Missions that the NPC can give out.
Definition: npc.h:748
int value
Definition: npc.h:242
int trust
Definition: npc.h:240
int owed
Definition: npc.h:244
int fear
Definition: npc.h:241
int anger
Definition: npc.h:243

References npc::add_new_mission(), npc_opinion::anger, npc::chatbin, npc_opinion::fear, overmapbuffer::find_npc(), follower_ids, Character::getID(), Character::global_omt_location(), npc::mission, npc_chatbin::mission_selected, npc_chatbin::missions, npc_chatbin::missions_assigned, NPC_MISSION_NULL, NPCATT_NULL, npc::op_of_u, ORIGIN_ANY_NPC, overmap_buffer, npc_opinion::owed, mission::reserve_random(), npc::set_attitude(), npc::set_fac(), npc_opinion::trust, and npc_opinion::value.

Referenced by cleanup_at_end().

◆ reset_zoom()

void game::reset_zoom ( )

Definition at line 7182 of file game.cpp.

7183{
7184#if defined(TILES)
7186 rescale_tileset( tileset_zoom );
7187#endif // TILES
7188}

References DEFAULT_TILESET_ZOOM, and tileset_zoom.

◆ revive_corpse()

bool game::revive_corpse ( const tripoint p,
item it 
)

Revives a corpse at given location.

The monster type and some of its properties are deducted from the corpse. If reviving succeeds, the location is guaranteed to have a new monster there (see critter_at).

Parameters
pThe place where to put the revived monster.
itThe corpse item, it must be a valid corpse (see item::is_corpse).
Returns
Whether the corpse has actually been redivided. Reviving may fail for many reasons, including no space to put the monster, corpse being to much damaged etc. If the monster was revived, the caller should remove the corpse item. If reviving failed, the item is unchanged, as is the environment (no new monsters).

Definition at line 4989 of file game.cpp.

4990{
4991 if( !it.is_corpse() ) {
4992 debugmsg( "Tried to revive a non-corpse." );
4993 return false;
4994 }
4995 shared_ptr_fast<monster> newmon_ptr = make_shared_fast<monster>
4996 ( it.get_mtype()->id );
4997 monster &critter = *newmon_ptr;
4998 critter.init_from_item( it );
4999 if( critter.get_hp() < 1 ) {
5000 // Failed reanimation due to corpse being too burned
5001 return false;
5002 }
5003 if( it.has_flag( "FIELD_DRESS" ) || it.has_flag( "FIELD_DRESS_FAILED" ) ||
5004 it.has_flag( "QUARTERED" ) ) {
5005 // Failed reanimation due to corpse being butchered
5006 return false;
5007 }
5008
5009 critter.no_extra_death_drops = true;
5010 critter.add_effect( effect_downed, 5_turns, num_bp );
5011 for( const item &component : it.components ) {
5012 critter.corpse_components.push_back( component );
5013 }
5014
5015 if( it.get_var( "zlave" ) == "zlave" ) {
5016 critter.add_effect( effect_pacified, 1_turns, num_bp );
5017 critter.add_effect( effect_pet, 1_turns, num_bp );
5018 }
5019
5020 if( it.get_var( "no_ammo" ) == "no_ammo" ) {
5021 for( auto &ammo : critter.ammo ) {
5022 ammo.second = 0;
5023 }
5024 }
5025
5026 return place_critter_at( newmon_ptr, p );
5027}
monster * place_critter_at(const mtype_id &id, const tripoint &p)
Adds critters to the reality bubble, creating them if necessary.
Definition: game.cpp:4786
double get_var(const std::string &name, double default_value) const
Definition: item.cpp:1025
const mtype * get_mtype() const
Definition: item.cpp:6496
std::list< item > components
Definition: item.h:2159
bool has_flag(const std::string &flag) const
Definition: item.cpp:5213
bool is_corpse() const
Whether this is a corpse item.
Definition: item.cpp:6491
int get_hp(const bodypart_id &) const override
Definition: monster.cpp:2919
bool no_extra_death_drops
Definition: monster.h:483
std::vector< item > corpse_components
Definition: monster.h:460
void init_from_item(const item &itm)
Initialize values like speed / hp from data of an item.
Definition: monster.cpp:2783
static const efftype_id effect_downed("downed")
static const efftype_id effect_pacified("pacified")

References monster::add_effect(), monster::ammo, item::components, monster::corpse_components, debugmsg, effect_downed, effect_pacified, effect_pet, monster::get_hp(), item::get_mtype(), item::get_var(), item::has_flag(), mtype::id, monster::init_from_item(), item::is_corpse(), monster::no_extra_death_drops, num_bp, and place_critter_at().

◆ save()

bool game::save ( )

Returns false if saving failed.

Definition at line 2893 of file game.cpp.

2894{
2895 try {
2896 if( !save_player_data() ||
2898 !save_artifacts() ||
2899 !save_maps() ||
2900 !get_auto_pickup().save_character() ||
2902 !get_safemode().save_character() ||
2903 !write_to_file( get_world_base_save_path() + "/uistate.json", [&]( std::ostream & fout ) {
2904 JsonOut jsout( fout );
2905 uistate.serialize( jsout );
2906 }, _( "uistate data" ) ) ) {
2907 return false;
2908 } else {
2909 world_generator->active_world->add_save( save_t::from_player_name( u.name ) );
2910 return true;
2911 }
2912 } catch( std::ios::failure &err ) {
2913 popup( _( "Failed to save game data" ) );
2914 return false;
2915 }
2916}
void write_to_file(const std::string &path, const std::function< void(std::ostream &)> &writer)
Definition: json.h:580
bool save_player_data()
Definition: game.cpp:2847
void serialize(JsonOut &json) const
@ failure
Definition: behavior.h:20

References _, behavior::failure, save_t::from_player_name(), get_auto_notes_settings(), get_auto_pickup(), get_safemode(), get_world_base_save_path(), Character::name, popup(), save(), save_artifacts(), save_factions_missions_npcs(), save_maps(), save_player_data(), uistatedata::serialize(), u, uistate, world_generator, and write_to_file().

Referenced by handle_action(), quicksave(), and save().

◆ save_artifacts()

bool game::save_artifacts ( )
private

Definition at line 2828 of file game.cpp.

2829{
2830 std::string artfilename = get_world_base_save_path() + "/" + SAVE_ARTIFACTS;
2831 return ::save_artifacts( artfilename );
2832}
bool save_artifacts(const std::string &path)
Definition: artifact.cpp:1277

References get_world_base_save_path(), SAVE_ARTIFACTS(), and save_artifacts().

Referenced by cleanup_at_end(), and save().

◆ save_cyborg()

void game::save_cyborg ( item cyborg,
const tripoint couch_pos,
player installer 
)

Turns Broken Cyborg monster into Cyborg NPC via surgery.

Definition at line 5029 of file game.cpp.

5030{
5031 int assist_bonus = installer.get_effect_int( effect_assisted );
5032
5033 float adjusted_skill = installer.bionics_adjusted_skill( skill_firstaid,
5036 -1 );
5037
5038 int damage = cyborg->damage();
5039 int dmg_lvl = cyborg->damage_level( 4 );
5040 int difficulty = 12;
5041
5042 if( damage != 0 ) {
5043
5044 popup( _( "WARNING: Patient's body is damaged. Difficulty of the procedure is increased by %s." ),
5045 dmg_lvl );
5046
5047 // Damage of the cyborg increases difficulty
5048 difficulty += dmg_lvl;
5049 }
5050
5051 int chance_of_success = bionic_manip_cos( adjusted_skill + assist_bonus, difficulty );
5052 int success = chance_of_success - rng( 1, 100 );
5053
5054 if( !g->u.query_yn(
5055 _( "WARNING: %i percent chance of SEVERE damage to all body parts! Continue anyway?" ),
5056 100 - static_cast<int>( chance_of_success ) ) ) {
5057 return;
5058 }
5059
5060 if( success > 0 ) {
5061 add_msg( m_good, _( "Successfully removed Personality override." ) );
5062 add_msg( m_bad, _( "Autodoc immediately destroys the CBM upon removal." ) );
5063
5064 m.i_rem( couch_pos, cyborg );
5065
5066 const string_id<npc_template> npc_cyborg( "cyborg_rescued" );
5067 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
5068 tmp->normalize();
5069 tmp->load_npc_template( npc_cyborg );
5070 tmp->spawn_at_precise( { get_levx(), get_levy() }, couch_pos );
5072 tmp->hurtall( dmg_lvl * 10, nullptr );
5073 tmp->add_effect( effect_downed, rng( 1_turns, 4_turns ), num_bp, 0, true );
5074 load_npcs();
5075
5076 } else {
5077 const int failure_level = static_cast<int>( std::sqrt( std::abs( success ) * 4.0 * difficulty /
5078 adjusted_skill ) );
5079 const int fail_type = std::min( 5, failure_level );
5080 switch( fail_type ) {
5081 case 1:
5082 case 2:
5083 add_msg( m_info, _( "The removal fails." ) );
5084 add_msg( m_bad, _( "The body is damaged." ) );
5085 cyborg->set_damage( damage + 1000 );
5086 break;
5087 case 3:
5088 case 4:
5089 add_msg( m_info, _( "The removal fails badly." ) );
5090 add_msg( m_bad, _( "The body is badly damaged!" ) );
5091 cyborg->set_damage( damage + 2000 );
5092 break;
5093 case 5:
5094 add_msg( m_info, _( "The removal is a catastrophe." ) );
5095 add_msg( m_bad, _( "The body is destroyed!" ) );
5096 m.i_rem( couch_pos, cyborg );
5097 break;
5098 default:
5099 break;
5100 }
5101
5102 }
5103
5104}
int bionic_manip_cos(float adjusted_skill, int bionic_difficulty)
Definition: bionics.cpp:1886
float bionics_adjusted_skill(const skill_id &most_important_skill, const skill_id &important_skill, const skill_id &least_important_skill, int skill_level=-1)
Calculate skill for (un)installing bionics.
Definition: bionics.cpp:1843
item & set_damage(int qty)
Filter setting damage constrained by min_damage and max_damage.
Definition: item.cpp:714
int damage_level(int max) const
Scale item damage to the given number of levels.
Definition: item.cpp:701
int damage() const
How much damage has the item sustained?
Definition: item.cpp:696
map_stack::iterator i_rem(const tripoint &p, map_stack::const_iterator it)
Definition: map.cpp:4092
static const skill_id skill_computer("computer")
static const efftype_id effect_assisted("assisted")
static const skill_id skill_electronics("electronics")
@ success
Definition: behavior.h:20

References _, add_msg(), bionic_manip_cos(), Character::bionics_adjusted_skill(), item::damage(), item::damage_level(), effect_assisted, effect_downed, g, Creature::get_effect_int(), get_levx(), get_levy(), map::i_rem(), overmapbuffer::insert_npc(), load_npcs(), m, m_bad, m_good, m_info, num_bp, overmap_buffer, popup(), rng(), item::set_damage(), skill_computer, skill_electronics, skill_firstaid, and behavior::success.

◆ save_factions_missions_npcs()

bool game::save_factions_missions_npcs ( )
private

Definition at line 2820 of file game.cpp.

2821{
2822 std::string masterfile = get_world_base_save_path() + "/" + SAVE_MASTER;
2823 return write_to_file( masterfile, [&]( std::ostream & fout ) {
2824 serialize_master( fout );
2825 }, _( "factions data" ) );
2826}
void serialize_master(std::ostream &fout)
Definition: savegame.cpp:1243

References _, get_world_base_save_path(), SAVE_MASTER(), serialize_master(), and write_to_file().

Referenced by cleanup_at_end(), and save().

◆ save_maps()

bool game::save_maps ( )
private

Definition at line 2834 of file game.cpp.

2835{
2836 try {
2837 m.save();
2838 overmap_buffer.save(); // can throw
2839 MAPBUFFER.save(); // can throw
2840 return true;
2841 } catch( const std::exception &err ) {
2842 popup( _( "Failed to save the maps: %s" ), err.what() );
2843 return false;
2844 }
2845}
void save(bool delete_after_save=false)
Store all submaps in this instance into savefiles.
Definition: mapbuffer.cpp:103

References _, m, MAPBUFFER, overmap_buffer, popup(), map::save(), overmapbuffer::save(), and mapbuffer::save().

Referenced by cleanup_at_end(), and save().

◆ save_player_data()

bool game::save_player_data ( )
private

Definition at line 2847 of file game.cpp.

2848{
2849 const std::string playerfile = get_player_base_save_path();
2850
2851 const bool saved_data = write_to_file( playerfile + SAVE_EXTENSION, [&]( std::ostream & fout ) {
2852 serialize( fout );
2853 }, _( "player data" ) );
2854 const bool saved_map_memory = u.save_map_memory();
2855 const bool saved_log = write_to_file( playerfile + SAVE_EXTENSION_LOG, [&](
2856 std::ostream & fout ) {
2857 fout << memorial().dump();
2858 }, _( "player memorial" ) );
2859#if defined(__ANDROID__)
2860 const bool saved_shortcuts = write_to_file( playerfile + SAVE_EXTENSION_SHORTCUTS, [&](
2861 std::ostream & fout ) {
2862 save_shortcuts( fout );
2863 }, _( "quick shortcuts" ) );
2864#endif
2865
2866 return saved_data && saved_map_memory && saved_log
2867#if defined(__ANDROID__)
2868 && saved_shortcuts
2869#endif
2870 ;
2871}
bool save_map_memory()
Definition: avatar.cpp:129
std::string get_player_base_save_path() const
Base path for saving player data.
Definition: game.cpp:12108
void serialize(std::ostream &fout)
Saving and loading functions.
Definition: savegame.cpp:69
std::string dump() const
Concatenates all of the memorial log entries, delimiting them with newlines, and returns the resultin...

References _, memorial_logger::dump(), get_player_base_save_path(), memorial(), SAVE_EXTENSION(), SAVE_EXTENSION_LOG(), SAVE_EXTENSION_SHORTCUTS(), avatar::save_map_memory(), serialize(), u, and write_to_file().

Referenced by save().

◆ serialize()

void game::serialize ( std::ostream &  fout)

Saving and loading functions.

Definition at line 69 of file savegame.cpp.

70{
71 /*
72 * Format version 12: Fully json, save the header. Weather and memorial exist elsewhere.
73 * To prevent (or encourage) confusion, there is no version 8. (cata 0.8 uses v7)
74 */
75 // Header
76 fout << "# version " << savegame_version << std::endl;
77
78 JsonOut json( fout, true ); // pretty-print
79
80 json.start_object();
81 // basic game state information.
82 json.member( "turn", calendar::turn );
84 json.member( "calendar_start", calendar_config._start_of_cataclysm );
85 json.member( "game_start", calendar_config._start_of_game );
86 json.member( "initial_season", static_cast<int>( calendar_config._initial_season ) );
87 json.member( "auto_travel_mode", auto_travel_mode );
88 json.member( "run_mode", static_cast<int>( safe_mode ) );
89 json.member( "mostseen", mostseen );
90 // current map coordinates
91 tripoint pos_sm = m.get_abs_sub();
92 const point pos_om = sm_to_om_remain( pos_sm.x, pos_sm.y );
93 json.member( "levx", pos_sm.x );
94 json.member( "levy", pos_sm.y );
95 json.member( "levz", pos_sm.z );
96 json.member( "om_x", pos_om.x );
97 json.member( "om_y", pos_om.y );
98
99 json.member( "grscent", scent.serialize() );
100 json.member( "typescent", scent.serialize( true ) );
101
102 // Then each monster
103 json.member( "active_monsters", *critter_tracker );
104 json.member( "stair_monsters", coming_to_stairs );
105
106 // save stats.
107 json.member( "kill_tracker", *kill_tracker_ptr );
108 json.member( "stats_tracker", *stats_tracker_ptr );
109 json.member( "achievements_tracker", *achievements_tracker_ptr );
110
111 json.member( "token_provider", *token_provider_ptr );
112
113 json.member( "player", u );
114 Messages::serialize( json );
115
116 json.end_object();
117}
A class that keeps time data other than current time.
Definition: calendar.h:530
season_type _initial_season
Definition: calendar.h:534
time_point _start_of_game
Definition: calendar.h:533
time_point _start_of_cataclysm
Definition: calendar.h:532
pimpl< drop_token_provider > token_provider_ptr
Definition: game.h:1001
std::string serialize(bool is_type=false) const
Definition: savegame.cpp:119
point sm_to_om_remain(int &x, int &y)
void serialize(JsonOut &json)
Definition: messages.cpp:321
calendar_config config
const int savegame_version
Definition: savegame.cpp:57

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, achievements_tracker_ptr, auto_travel_mode, coming_to_stairs, calendar::config, critter_tracker, JsonOut::end_object(), map::get_abs_sub(), kill_tracker_ptr, m, JsonOut::member(), mostseen, safe_mode, savegame_version, scent, scent_map::serialize(), Messages::serialize(), sm_to_om_remain(), JsonOut::start_object(), stats_tracker_ptr, token_provider_ptr, calendar::turn, u, point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

Referenced by save_player_data().

◆ serialize_master()

void game::serialize_master ( std::ostream &  fout)
private

Definition at line 1243 of file savegame.cpp.

1244{
1245 fout << "# version " << savegame_version << std::endl;
1246 try {
1247 JsonOut json( fout, true ); // pretty-print
1248 json.start_object();
1249
1250 json.member( "next_mission_id", next_mission_id );
1251 json.member( "next_npc_id", next_npc_id );
1252
1253 json.member( "active_missions" );
1254 mission::serialize_all( json );
1255
1256 json.member( "factions", *faction_manager_ptr );
1257 json.member( "seed", seed );
1258
1259 json.member( "weather" );
1260 json.start_object();
1261 json.member( "lightning", get_weather().lightning_active );
1262 json.end_object();
1263
1264 json.end_object();
1265 } catch( const JsonError &e ) {
1266 debugmsg( "error saving to %s: %s", SAVE_MASTER, e.c_str() );
1267 }
1268}
Definition: json.h:51
const char * c_str() const noexcept
Definition: json.h:54
static void serialize_all(JsonOut &json)
Definition: savegame.cpp:1234

References JsonError::c_str(), debugmsg, JsonOut::end_object(), faction_manager_ptr, get_weather, JsonOut::member(), next_mission_id, next_npc_id, SAVE_MASTER(), savegame_version, seed, mission::serialize_all(), and JsonOut::start_object().

Referenced by save_factions_missions_npcs().

◆ set_critter_died()

void game::set_critter_died ( )

If invoked, dead will be cleaned this turn.

Definition at line 1897 of file game.cpp.

1898{
1899 critter_died = true;
1900}

References critter_died.

◆ set_driving_view_offset()

void game::set_driving_view_offset ( const point p)

Definition at line 1707 of file game.cpp.

1708{
1709 // remove the previous driving offset,
1710 // store the new offset and apply the new offset.
1717}

References driving_view_offset, u, player::view_offset, point::x, tripoint::x, point::y, and tripoint::y.

Referenced by calc_driving_offset(), and cleanup_at_end().

◆ set_npcs_dirty()

void game::set_npcs_dirty ( )

If invoked, NPCs will be reloaded before next turn.

Definition at line 1892 of file game.cpp.

1893{
1894 npcs_dirty = true;
1895}

References npcs_dirty.

◆ set_safe_mode()

void game::set_safe_mode ( safe_mode_type  mode)

Definition at line 8729 of file game.cpp.

8730{
8731 safe_mode = mode;
8733}

References safe_mode, and safe_mode_warning_logged.

Referenced by handle_action(), and mon_info_update().

◆ set_zoom()

void game::set_zoom ( int  level)

Definition at line 7190 of file game.cpp.

7191{
7192#if defined(TILES)
7193 if( tileset_zoom != level ) {
7194 tileset_zoom = level;
7195 rescale_tileset( tileset_zoom );
7196 }
7197#else
7198 static_cast<void>( level );
7199#endif // TILES
7200}

References tileset_zoom.

Referenced by look_around().

◆ setremoteveh()

void game::setremoteveh ( vehicle veh)

Sets the current remotely controlled vehicle.

Definition at line 2379 of file game.cpp.

2380{
2382 remoteveh_cache = veh;
2383 if( veh != nullptr && !u.has_active_bionic( bio_remote ) &&
2385 debugmsg( "Tried to set remote vehicle without bio_remote or remotevehcontrol" );
2386 veh = nullptr;
2387 }
2388
2389 if( veh == nullptr ) {
2390 u.remove_value( "remote_controlling_vehicle" );
2391 return;
2392 }
2393
2394 std::stringstream remote_veh_string;
2395 const tripoint vehpos = veh->global_pos3();
2396 remote_veh_string << vehpos.x << ' ' << vehpos.y << ' ' << vehpos.z;
2397 u.set_value( "remote_controlling_vehicle", remote_veh_string.str() );
2398}
void remove_value(const std::string &key)
Definition: creature.cpp:1336

References bio_remote, debugmsg, vehicle::global_pos3(), Character::has_active_bionic(), Character::has_active_item(), itype_remotevehcontrol, remoteveh_cache, remoteveh_cache_time, Creature::remove_value(), Creature::set_value(), calendar::turn, u, tripoint::x, tripoint::y, and tripoint::z.

◆ setup()

void game::setup ( )

Definition at line 574 of file game.cpp.

575{
576 loading_ui ui( true );
577 {
580 popup.message( "%s", _( "Please wait while the world data loads…\nLoading core data" ) );
583
585 }
586
588
589 if( get_option<bool>( "ELEVATED_BRIDGES" ) && !get_option<bool>( "ZLEVELS" ) ) {
590 debugmsg( "\"Elevated bridges\" mod requires z-levels to be ENABLED to work properly!" );
591 }
592
593 m = map( get_option<bool>( "ZLEVELS" ) );
594
596 next_mission_id = 1;
597 new_game = true;
598 uquit = QUIT_NO; // We haven't quit the game
599 bVMonsterLookFire = true;
600
601 // invalidate calendar caches in case we were previously playing
602 // a different world
603 calendar::set_eternal_season( ::get_option<bool>( "ETERNAL_SEASON" ) );
604 calendar::set_season_length( ::get_option<int>( "SEASON_LENGTH" ) );
605
608
609 turnssincelastmon = 0; //Auto safe mode init
610
613 coming_to_stairs.clear();
614 active_npc.clear();
615 faction_manager_ptr->clear();
620
621 SCT.vSCT.clear(); //Delete pending messages
622
623 stats().clear();
624 // reset kill counts
625 kill_tracker_ptr->clear();
627 // reset follower list
628 follower_ids.clear();
629 scent.reset();
630
632 remoteveh_cache = nullptr;
633
634 token_provider_ptr->clear();
635 // back to menu for save loading, new game etc
636}
void clear_zombies()
Redirects to the creature_tracker clear() function.
Definition: game.cpp:4863
void load_world_modfiles(loading_ui &ui)
Loads core data and mods from the active world.
Definition: game.cpp:2727
static void clear_all()
Remove all active missions, used to cleanup on exit and before reloading a new game.
Definition: mission.cpp:127
void reset()
Definition: scent_map.cpp:51
static const string_id< weather_type > & NULL_ID()
Returns a null id whose string_id<T>::is_null() must always return true.
void clear_messages()
Definition: messages.cpp:351
void reset_sounds()
Definition: sounds.cpp:565

References _, achievements_tracker_ptr, active_npc, calendar::before_time_starts, bVMonsterLookFire, character_id, explosion_handler::explosion_queue::clear(), stats_tracker::clear(), mission::clear_all(), Messages::clear_messages(), clear_zombies(), coming_to_stairs, debugmsg, faction_manager_ptr, follower_ids, explosion_handler::get_explosion_queue(), get_weather, kill_tracker_ptr, load_core_data(), load_world_modfiles(), m, new_game, next_mission_id, next_npc_id, weather_manager::nextweather, string_id< weather_type >::NULL_ID(), popup(), QUIT_NO, ui_manager::redraw(), refresh_display(), remoteveh_cache, remoteveh_cache_time, scent_map::reset(), sounds::reset_sounds(), scent, SCT, calendar::set_eternal_season(), calendar::set_season_length(), stats(), timed_events, token_provider_ptr, turnssincelastmon, uquit, scrollingcombattext::vSCT, and weather_manager::weather_id.

Referenced by butcher_submenu(), and quickload().

◆ shared_from()

template<typename T >
template shared_ptr_fast< npc > game::shared_from< npc > ( const T &  critter)

Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature).

The function may return an empty pointer if the given critter is not stored anywhere (e.g. it was allocated on the stack, not stored in the critter_tracker nor in active_npc nor is it u).

Definition at line 4716 of file game.cpp.

4717{
4718 if( static_cast<const Creature *>( &critter ) == static_cast<const Creature *>( &u ) ) {
4719 // u is not stored in a shared_ptr, but it won't go out of scope anyway
4720 return std::dynamic_pointer_cast<T>( u_shared_ptr );
4721 }
4722 if( critter.is_monster() ) {
4723 if( const shared_ptr_fast<monster> mon_ptr = critter_tracker->find( critter.pos() ) ) {
4724 if( static_cast<const Creature *>( mon_ptr.get() ) == static_cast<const Creature *>( &critter ) ) {
4725 return std::dynamic_pointer_cast<T>( mon_ptr );
4726 }
4727 }
4728 }
4729 if( critter.is_npc() ) {
4730 for( auto &cur_npc : active_npc ) {
4731 if( static_cast<const Creature *>( cur_npc.get() ) == static_cast<const Creature *>( &critter ) ) {
4732 return std::dynamic_pointer_cast<T>( cur_npc );
4733 }
4734 }
4735 }
4736 return nullptr;
4737}

References active_npc, critter_tracker, u, and u_shared_ptr.

Referenced by list_monsters(), mon_info_update(), and validate_mounted_npcs().

◆ shift_destination_preview()

void game::shift_destination_preview ( const point delta)

Definition at line 12121 of file game.cpp.

12122{
12123 for( tripoint &p : destination_preview ) {
12124 p += delta;
12125 }
12126}

References destination_preview.

◆ shift_monsters()

void game::shift_monsters ( const tripoint shift)
private

Shift all active monsters, the shift vector is the number of shifted submaps.

Monsters that are outside of the reality bubble after shifting are despawned. Note on z-levels: this works with vertical shifts, but currently all monsters are despawned upon a vertical shift.

Definition at line 11126 of file game.cpp.

11127{
11128 // If either shift argument is non-zero, we're shifting.
11129 if( shift == tripoint_zero ) {
11130 return;
11131 }
11132 for( monster &critter : all_monsters() ) {
11133 if( shift.xy() != point_zero ) {
11134 critter.shift( shift.xy() );
11135 }
11136
11137 if( m.inbounds( critter.pos() ) && ( shift.z == 0 || m.has_zlevels() ) ) {
11138 // We're inbounds, so don't despawn after all.
11139 // No need to shift Z-coordinates, they are absolute
11140 continue;
11141 }
11142 // Either a vertical shift or the critter is now outside of the reality bubble,
11143 // anyway: it must be saved and removed.
11144 despawn_monster( critter );
11145 }
11146 // The order in which zombies are shifted may cause zombies to briefly exist on
11147 // the same square. This messes up the mon_at cache, so we need to rebuild it.
11148 critter_tracker->rebuild_cache();
11149}

References all_monsters(), critter_tracker, despawn_monster(), map::has_zlevels(), map::inbounds(), m, point_zero, tripoint_zero, tripoint::xy(), and tripoint::z.

Referenced by update_map(), vertical_move(), and vertical_shift().

◆ slip_down()

bool game::slip_down ( )

Checks if player is able to successfully climb to/from some terrain and not slip down.

Returns
whether player has slipped down
Dexterity decreases chances of slipping while climbing

Definition at line 12128 of file game.cpp.

12129{
12130 ///\EFFECT_DEX decreases chances of slipping while climbing
12131 int climb = u.dex_cur;
12132 if( u.has_trait( trait_BADKNEES ) ) {
12133 climb = climb / 2;
12134 }
12135 if( one_in( climb ) ) {
12136 add_msg( m_bad, _( "You slip while climbing and fall down again." ) );
12137 if( climb <= 1 ) {
12138 add_msg( m_bad, _( "Climbing is impossible in your current state." ) );
12139 }
12140 return true;
12141 }
12142 return false;
12143}
static const trait_id trait_BADKNEES("BADKNEES")

References _, add_msg(), Character::dex_cur, Character::has_trait(), m_bad, one_in(), trait_BADKNEES, and u.

◆ spawn_hallucination()

bool game::spawn_hallucination ( const tripoint p)

Spawns a hallucination at a determined position.

Attempts to spawn a hallucination at given location.

Returns false if the hallucination couldn't be spawned for whatever reason, such as a monster already in the target square.

Returns
Whether or not a hallucination was successfully spawned.

Definition at line 4874 of file game.cpp.

4875{
4876 if( one_in( 100 ) ) {
4877 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
4878 tmp->normalize();
4879 tmp->randomize( NC_HALLU );
4880 tmp->spawn_at_precise( { get_levx(), get_levy() }, p );
4881 if( !critter_at( p, true ) ) {
4883 load_npcs();
4884 return true;
4885 } else {
4886 return false;
4887 }
4888 }
4889
4891 const shared_ptr_fast<monster> phantasm = make_shared_fast<monster>( mt );
4892 phantasm->hallucination = true;
4893 phantasm->spawn( p );
4894
4895 //Don't attempt to place phantasms inside of other creatures
4896 if( !critter_at( phantasm->pos(), true ) ) {
4897 return critter_tracker->add( phantasm );
4898 } else {
4899 return false;
4900 }
4901}
mtype_id get_valid_hallucination() const
static MonsterGenerator & generator()
npc_class_id NC_HALLU("NC_HALLU")

References critter_at(), critter_tracker, MonsterGenerator::generator(), get_levx(), get_levy(), MonsterGenerator::get_valid_hallucination(), overmapbuffer::insert_npc(), load_npcs(), NC_HALLU, one_in(), and overmap_buffer.

◆ spell_events_subscriber()

spell_events & game::spell_events_subscriber ( )

Definition at line 2888 of file game.cpp.

2889{
2890 return *spell_events_ptr;
2891}

References spell_events_ptr.

◆ start_calendar()

void game::start_calendar ( )

Definition at line 11690 of file game.cpp.

11691{
11692 const bool scen_season = scen->has_flag( "SPR_START" ) || scen->has_flag( "SUM_START" ) ||
11693 scen->has_flag( "AUT_START" ) || scen->has_flag( "WIN_START" ) ||
11694 scen->has_flag( "SUM_ADV_START" );
11695
11697 if( scen_season ) {
11698 // Configured starting date overridden by scenario, calendar_config.start is left as Spring 1
11700 get_option<int>( "INITIAL_TIME" );
11701 calendar_config._start_of_game = calendar::turn_zero + 1_hours * get_option<int>( "INITIAL_TIME" );
11702 if( scen->has_flag( "SPR_START" ) ) {
11704 } else if( scen->has_flag( "SUM_START" ) ) {
11707 } else if( scen->has_flag( "AUT_START" ) ) {
11710 } else if( scen->has_flag( "WIN_START" ) ) {
11713 } else if( scen->has_flag( "SUM_ADV_START" ) ) {
11716 } else {
11717 debugmsg( "The Unicorn" );
11718 }
11719 } else {
11720 // No scenario, so use the starting date+time configured in world options
11721 int initial_days = get_option<int>( "INITIAL_DAY" );
11722 if( initial_days == -1 ) {
11723 // 0 - 363 for a 91 day season
11724 initial_days = rng( 0, get_option<int>( "SEASON_LENGTH" ) * 4 - 1 );
11725 }
11727
11728 // Determine the season based off how long the seasons are set to be
11729 // First take the number of season elapsed up to the starting date, then mod by 4 to get the season of the current year
11730 const int season_number = ( initial_days / get_option<int>( "SEASON_LENGTH" ) ) % 4;
11731 if( season_number == 0 ) {
11733 } else if( season_number == 1 ) {
11735 } else if( season_number == 2 ) {
11737 } else {
11739 }
11740
11742 + 1_hours * get_option<int>( "INITIAL_TIME" )
11743 + 1_days * get_option<int>( "SPAWN_DELAY" );
11744 }
11745
11747}
@ WINTER
Definition: calendar.h:21
@ AUTUMN
Definition: calendar.h:20
@ SUMMER
Definition: calendar.h:19
@ SPRING
Definition: calendar.h:18
time_duration season_length() const
Definition: calendar.h:569
const scenario * scen
Definition: game.h:1008
bool has_flag(const std::string &flag) const
Such as a seasonal start, fiery start, surrounded start, etc.
Definition: scenario.cpp:439

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, AUTUMN, calendar::config, debugmsg, scenario::has_flag(), rng(), scen, calendar_config::season_length(), SPRING, SUMMER, calendar::turn, calendar::turn_zero, and WINTER.

Referenced by start_game().

◆ start_game()

bool game::start_game ( )
private

Definition at line 662 of file game.cpp.

663{
664 if( !gamemode ) {
665 gamemode = std::make_unique<special_game>();
666 }
667
668 seed = rng_bits();
669 new_game = true;
672 safe_mode = ( get_option<bool>( "SAFEMODE" ) ? SAFE_MODE_ON : SAFE_MODE_OFF );
673 mostseen = 0; // ...and mostseen is 0, we haven't seen any monsters yet.
676
678
681 popup.message( "%s", _( "Please wait as we build your world" ) );
684
685 load_master();
686 u.setID( assign_npc_id() ); // should be as soon as possible, but *after* load_master
687
691 do {
692 omtstart = start_loc.find_player_initial_location();
693 if( omtstart == overmap::invalid_tripoint ) {
694 if( query_yn(
695 _( "Try again?\n\nIt may require several attempts until the game finds a valid starting location." ) ) ) {
698 } else {
699 return false;
700 }
701 }
702 } while( omtstart == overmap::invalid_tripoint );
703
704 start_loc.prepare_map( omtstart );
705
706 // Place vehicles spawned by scenario or profession, has to be placed very early to avoid bugs.
707 if( u.starting_vehicle &&
708 !place_vehicle_nearby( u.starting_vehicle, omtstart.xy(), 0, 30,
709 std::vector<std::string> {} ) ) {
710 debugmsg( "could not place starting vehicle" );
711 }
712
713 if( scen->has_map_extra() ) {
714 // Map extras can add monster spawn points and similar and should be done before the main
715 // map is loaded.
716 start_loc.add_map_extra( omtstart, scen->get_map_extra() );
717 }
718
719 // TODO: fix point types
720 tripoint lev = project_to<coords::sm>( omtstart ).raw();
721 // The player is centered in the map, but lev[xyz] refers to the top left point of the map
722 lev.x -= HALF_MAPSIZE;
723 lev.y -= HALF_MAPSIZE;
724 load_map( lev, /*pump_events=*/true );
725
728 // Do this after the map cache has been built!
729 start_loc.place_player( u );
730 // ...but then rebuild it, because we want visibility cache to avoid spawning monsters in sight
733 // Start the overmap with out immediate neighborhood visible, this needs to be after place_player
735 get_option<int>( "DISTANCE_INITIAL_VISIBILITY" ), 0 );
736
737 u.moves = 0;
738 u.process_turn(); // process_turn adds the initial move points
742 u.next_climate_control_check = calendar::before_time_starts; // Force recheck at startup
744
745 //Reset character safe mode/pickup rules
750
751 //Put some NPCs in there!
752 if( get_option<std::string>( "STARTING_NPC" ) == "always" ||
753 ( get_option<std::string>( "STARTING_NPC" ) == "scenario" &&
754 !g->scen->has_flag( "LONE_START" ) ) ) {
756 }
757 //Load NPCs. Set nearby npcs to active.
758 load_npcs();
759 // Spawn the monsters
760 const bool spawn_near =
761 get_option<bool>( "BLACK_ROAD" ) || g->scen->has_flag( "SUR_START" );
762 // Surrounded start ones
763 if( spawn_near ) {
764 start_loc.surround_with_monsters( omtstart, mongroup_id( "GROUP_ZOMBIE" ), 70 );
765 }
766
767 m.spawn_monsters( !spawn_near ); // Static monsters
768
769 // Make sure that no monsters are near the player
770 // This can happen in lab starts
771 if( !spawn_near ) {
772 for( monster &critter : all_monsters() ) {
773 if( rl_dist( critter.pos(), u.pos() ) <= 5 ||
774 m.clear_path( critter.pos(), u.pos(), 40, 1, 100 ) ) {
775 remove_zombie( critter );
776 }
777 }
778 }
779
780 //Create mutation_category_level
782 //Calculate mutation drench protection stats
785 if( scen->has_flag( "FIRE_START" ) ) {
786 start_loc.burn( omtstart, 3, 3 );
787 }
788 if( scen->has_flag( "INFECTED" ) ) {
790 }
791 if( scen->has_flag( "BAD_DAY" ) ) {
792 u.add_effect( effect_flu, 1000_minutes );
793 u.add_effect( effect_drunk, 270_minutes );
794 u.add_morale( MORALE_FEELING_BAD, -100, -100, 50_minutes, 50_minutes );
795 }
796 if( scen->has_flag( "HELI_CRASH" ) ) {
797 start_loc.handle_heli_crash( u );
798 bool success = false;
799 for( auto v : m.get_vehicles() ) {
800 std::string name = v.v->type.str();
801 std::string search = std::string( "helicopter" );
802 if( name.find( search ) != std::string::npos ) {
803 for( const vpart_reference &vp : v.v->get_any_parts( VPFLAG_CONTROLS ) ) {
804 const tripoint pos = vp.pos();
805 u.setpos( pos );
806
807 // Delete the items that would have spawned here from a "corpse"
808 for( auto sp : v.v->parts_at_relative( vp.mount(), true ) ) {
809 vehicle_stack here = v.v->get_items( sp );
810
811 for( auto iter = here.begin(); iter != here.end(); ) {
812 iter = here.erase( iter );
813 }
814 }
815
816 auto mons = critter_tracker->find( pos );
817 if( mons != nullptr ) {
818 critter_tracker->remove( *mons );
819 }
820
821 success = true;
822 break;
823 }
824 if( success ) {
825 v.v->name = "Bird Wreckage";
826 break;
827 }
828 }
829 }
830 }
831 if( scen->has_flag( "BORDERED" ) ) {
832 overmap &starting_om = get_cur_om();
833 for( int z = -OVERMAP_DEPTH; z <= OVERMAP_HEIGHT; z++ ) {
834 starting_om.place_special_forced( overmap_special_id( "world" ), { 0, 0, z },
836 }
837
838 }
839 for( auto &e : u.inv_dump() ) {
840 e->set_owner( g->u );
841 }
842 // Now that we're done handling coordinates, ensure the player's submap is in the center of the map
843 update_map( u );
844 // Profession pets
845 for( const mtype_id &elem : u.starting_pets ) {
846 if( monster *const mon = place_critter_around( elem, u.pos(), 5 ) ) {
847 mon->friendly = -1;
848 mon->add_effect( effect_pet, 1_turns, num_bp );
849 } else {
850 add_msg( m_debug, "cannot place starting pet, no space!" );
851 }
852 }
853 // Assign all of this scenario's missions to the player.
854 for( const mission_type_id &m : scen->missions() ) {
855 const auto mission = mission::reserve_new( m, character_id() );
856 mission->assign( u );
857 }
858
859 g->events().send<event_type::game_start>( u.getID() );
860 return true;
861}
body_part random_body_part(bool main_parts_only)
Returns a random body_part token.
Definition: bodypart.cpp:364
bool last_climate_control_ret
Definition: character.h:2215
void drench_mut_calc()
Recalculates mutation drench protection for all bodyparts (ignored/good/neutral stats)
Definition: character.cpp:7946
void set_stamina(int new_stamina)
Definition: character.cpp:7208
time_point next_climate_control_check
Definition: character.h:2214
int get_stamina_max() const
Definition: character.cpp:7199
void set_highest_cat_level()
Recalculates mutation_category_level[] values for the player.
Definition: character.cpp:7923
void default_initialize()
Perform default initialization.
Definition: auto_note.cpp:101
void start_calendar()
Definition: game.cpp:11690
void create_starting_npcs()
Definition: game.cpp:989
overmap & get_cur_om() const
The overmap which contains the center submap of the reality bubble.
Definition: game.cpp:11988
vehicle * place_vehicle_nearby(const vproto_id &id, const point_abs_omt &origin, int min_distance, int max_distance, const std::vector< std::string > &omt_search_types={})
Definition: game.cpp:863
bool clear_path(const tripoint &f, const tripoint &t, int range, int cost_min, int cost_max) const
Check whether there's a direct line of sight between F and T with the additional movecost restraints.
Definition: map.cpp:6394
static mission * reserve_new(const mission_type_id &type, const character_id &npc_id)
Create a new mission of the given type and assign it to the given npc.
Definition: mission.cpp:64
void assign(avatar &u)
Assigns the mission to the player.
Definition: mission.cpp:210
void place_special_forced(const overmap_special_id &special_id, const tripoint_om_omt &p, om_direction::type dir)
Definition: overmap.cpp:2163
bool reveal(const point_abs_omt &center, int radius, int z)
Mark a square area around center on Z-level z as seen.
bool random_start_location
Definition: player.h:594
vproto_id starting_vehicle
Definition: player.h:606
std::vector< mtype_id > starting_pets
Definition: player.h:607
start_location_id start_location
Definition: player.h:595
void clear_character_rules()
bool has_map_extra() const
Definition: scenario.cpp:454
const std::string & get_map_extra() const
Definition: scenario.cpp:458
const std::vector< mission_type_id > & missions() const
Definition: scenario.cpp:462
start_location_id random_start_location() const
Definition: scenario.cpp:232
void burn(const tripoint_abs_omt &omtstart, size_t count, int rad) const
Burn random terrain / furniture with FLAMMABLE or FLAMMABLE_ASH tag.
void surround_with_monsters(const tripoint_abs_omt &omtstart, const mongroup_id &type, float expected_points) const
Adds surround start monsters.
void prepare_map(const tripoint_abs_omt &omtstart) const
Initialize the map at players start location using prepare_map.
void place_player(player &u) const
Place the player somewhere in the reality bubble (g->m).
void handle_heli_crash(player &u) const
tripoint_abs_omt find_player_initial_location() const
Find a suitable start location on the overmap.
void add_map_extra(const tripoint_abs_omt &omtstart, const std::string &map_extra) const
Adds a map extra, see map_extras.h and map_extras.cpp.
const T & obj() const
Returns the actual object this id refers to.
Definition: achievement.cpp:58
iterator erase(const_iterator it) override
Definition: vehicle.cpp:230
static const efftype_id effect_drunk("drunk")
static const efftype_id effect_infected("infected")
static const efftype_id effect_accumulated_mutagen("accumulated_mutagen")
static const efftype_id effect_flu("flu")
static constexpr int SPRING_TEMPERATURE
Base starting spring temperature in F used for climate, weather and temperature calculation.
void update_weather()
Definition: weather.cpp:1056
const morale_type MORALE_FEELING_BAD("morale_feeling_bad")
static bool search(const ui_adaptor &om_ui, tripoint_abs_omt &curs, const tripoint_abs_omt &orig)
unsigned int rng_bits()
Definition: rng.cpp:12
string_id< overmap_special > overmap_special_id
Definition: type_id.h:134
string_id< MonsterGroup > mongroup_id
Definition: type_id.h:105
@ VPFLAG_CONTROLS
Definition: veh_type.h:41

References _, Creature::add_effect(), start_location::add_map_extra(), Character::add_morale(), add_msg(), all_monsters(), mission::assign(), assign_npc_id(), calendar::before_time_starts, item_stack::begin(), map::build_map_cache(), start_location::burn(), character_id, auto_notes::auto_note_settings::clear(), overmapbuffer::clear(), auto_pickup::player_settings::clear_character_rules(), safemode::clear_character_rules(), map::clear_path(), create_starting_npcs(), critter_tracker, debugmsg, auto_notes::auto_note_settings::default_initialize(), Character::drench_mut_calc(), effect_accumulated_mutagen, effect_drunk, effect_flu, effect_infected, effect_pet, item_stack::end(), vehicle_stack::erase(), start_location::find_player_initial_location(), g, game_start, gamemode, get_auto_notes_settings(), get_auto_pickup(), get_cur_om(), get_distraction_manager(), get_levz(), scenario::get_map_extra(), get_safemode(), Character::get_stamina_max(), map::get_vehicles(), get_weather, Character::getID(), Character::global_omt_location(), HALF_MAPSIZE, start_location::handle_heli_crash(), scenario::has_flag(), scenario::has_map_extra(), init_autosave(), Character::inv_dump(), overmap::invalid_tripoint, map::invalidate_map_cache(), Character::last_climate_control_ret, distraction_manager::distraction_manager_gui::load(), safemode::load_global(), load_map(), load_master(), load_npcs(), m, m_debug, MAPBUFFER, scenario::missions(), MORALE_FEELING_BAD, mostseen, Creature::moves, om_direction::name(), new_game, Character::next_climate_control_check, weather_manager::nextweather, om_direction::north, num_bp, string_id< T >::obj(), overmap_buffer, OVERMAP_DEPTH, OVERMAP_HEIGHT, place_critter_around(), start_location::place_player(), overmap::place_special_forced(), place_vehicle_nearby(), popup(), Character::pos(), start_location::prepare_map(), player::process_turn(), query_yn(), random_body_part(), player::random_start_location, scenario::random_start_location(), ui_manager::redraw(), refresh_display(), remove_zombie(), mission::reserve_new(), mapbuffer::reset(), overmapbuffer::reveal(), rl_dist(), rng_bits(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, scen, overmap_ui::search(), seed, Character::set_highest_cat_level(), Character::set_stamina(), Character::setID(), Character::setpos(), map::spawn_monsters(), SPRING_TEMPERATURE, start_calendar(), player::start_location, player::starting_pets, player::starting_vehicle, behavior::success, start_location::surround_with_monsters(), weather_manager::temperature, calendar::turn, u, update_map(), weather_manager::update_weather(), VPFLAG_CONTROLS, tripoint::x, coords::coord_point< Point, Origin, Scale >::xy(), and tripoint::y.

◆ start_hauling()

void game::start_hauling ( const tripoint pos)

Definition at line 10489 of file game.cpp.

10490{
10491 // Find target items and quantities thereof for the new activity
10492 std::vector<item_location> target_items;
10493 std::vector<int> quantities;
10494
10495 map_stack items = m.i_at( pos );
10496 for( item &it : items ) {
10497 // Liquid cannot be picked up
10498 if( it.made_of( LIQUID ) ) {
10499 continue;
10500 }
10501 target_items.emplace_back( map_cursor( pos ), &it );
10502 // Quantity of 0 means move all
10503 quantities.push_back( 0 );
10504 }
10505
10506 if( target_items.empty() ) {
10507 // Nothing to haul
10508 return;
10509 }
10510
10511 // Whether the destination is inside a vehicle (not supported)
10512 const bool to_vehicle = false;
10513 // Destination relative to the player
10514 const tripoint relative_destination{};
10515
10517 target_items,
10518 quantities,
10519 to_vehicle,
10520 relative_destination
10521 ) ) );
10522}

References Character::assign_activity(), map::i_at(), LIQUID, m, and u.

Referenced by vertical_move(), and walk_move().

◆ stats()

stats_tracker & game::stats ( )

Definition at line 2878 of file game.cpp.

2879{
2880 return *stats_tracker_ptr;
2881}

References stats_tracker_ptr.

Referenced by death_screen(), handle_action(), setup(), and win().

◆ swap_critters()

bool game::swap_critters ( Creature a,
Creature b 
)

Swaps positions of two creatures.

Definition at line 4903 of file game.cpp.

4904{
4905 if( &a == &b ) {
4906 // No need to do anything, but print a debugmsg anyway
4907 debugmsg( "Tried to swap %s with itself", a.disp_name() );
4908 return true;
4909 }
4910 if( critter_at( a.pos() ) != &a ) {
4911 debugmsg( "Tried to swap when it would cause a collision between %s and %s.",
4912 b.disp_name(), critter_at( a.pos() )->disp_name() );
4913 return false;
4914 }
4915 if( critter_at( b.pos() ) != &b ) {
4916 debugmsg( "Tried to swap when it would cause a collision between %s and %s.",
4917 a.disp_name(), critter_at( b.pos() )->disp_name() );
4918 return false;
4919 }
4920 // Simplify by "sorting" the arguments
4921 // Only the first argument can be u
4922 // If swapping player/npc with a monster, monster is second
4923 bool a_first = a.is_player() ||
4924 ( a.is_npc() && !b.is_player() );
4925 Creature &first = a_first ? a : b;
4926 Creature &second = a_first ? b : a;
4927 // Possible options:
4928 // both first and second are monsters
4929 // second is a monster, first is a player or an npc
4930 // first is a player, second is an npc
4931 // both first and second are npcs
4932 if( first.is_monster() ) {
4933 monster *m1 = dynamic_cast< monster * >( &first );
4934 monster *m2 = dynamic_cast< monster * >( &second );
4935 if( m1 == nullptr || m2 == nullptr || m1 == m2 ) {
4936 debugmsg( "Couldn't swap two monsters" );
4937 return false;
4938 }
4939
4940 critter_tracker->swap_positions( *m1, *m2 );
4941 return true;
4942 }
4943
4944 player *u_or_npc = dynamic_cast< player * >( &first );
4945 player *other_npc = dynamic_cast< player * >( &second );
4946
4947 if( u_or_npc->in_vehicle ) {
4948 m.unboard_vehicle( u_or_npc->pos() );
4949 }
4950
4951 if( other_npc && other_npc->in_vehicle ) {
4952 m.unboard_vehicle( other_npc->pos() );
4953 }
4954
4955 tripoint temp = second.pos();
4956 second.setpos( first.pos() );
4957
4958 if( first.is_player() ) {
4959 walk_move( temp );
4960 } else {
4961 first.setpos( temp );
4962 if( m.veh_at( u_or_npc->pos() ).part_with_feature( VPFLAG_BOARDABLE, true ) ) {
4963 m.board_vehicle( u_or_npc->pos(), u_or_npc );
4964 }
4965 }
4966
4967 if( other_npc && m.veh_at( other_npc->pos() ).part_with_feature( VPFLAG_BOARDABLE, true ) ) {
4968 m.board_vehicle( other_npc->pos(), other_npc );
4969 }
4970 return true;
4971}
virtual bool is_monster() const
Definition: creature.h:101
virtual bool is_player() const
Definition: creature.h:92
virtual void setpos(const tripoint &pos)=0
bool walk_move(const tripoint &dest, bool via_ramp=false)
Definition: game.cpp:8868
constexpr double a
Definition: magic.cpp:1030
constexpr double b
Definition: magic.cpp:1031
@ VPFLAG_BOARDABLE
Definition: veh_type.h:39

References a, b, map::board_vehicle(), critter_at(), critter_tracker, debugmsg, Character::in_vehicle, Creature::is_monster(), Creature::is_player(), m, optional_vpart_position::part_with_feature(), Creature::pos(), Character::pos(), second, Creature::setpos(), map::unboard_vehicle(), map::veh_at(), VPFLAG_BOARDABLE, and walk_move().

Referenced by npc_menu().

◆ take_screenshot() [1/2]

bool game::take_screenshot ( ) const

Saves a screenshot of the current viewport, as a PNG file.

Filesystem location is derived from the current world and character.

Note
: Only works for SDL/TILES (otherwise the function returns false). A window (more precisely, a viewport) must already exist and the SDL renderer must be valid.
Returns
true if the screenshot generation was successful, false otherwise.

Definition at line 7259 of file game.cpp.

7260{
7261 popup( _( "This binary was not compiled with tiles support." ) );
7262 return false;
7263}

References _, and popup().

Referenced by do_turn().

◆ take_screenshot() [2/2]

bool game::take_screenshot ( const std::string &  file_path) const

Saves a screenshot of the current viewport, as a PNG file, to the given location.

Parameters
file_pathA full path to the file where the screenshot should be saved.
Note
: Only works for SDL/TILES (otherwise the function returns false). A window (more precisely, a viewport) must already exist and the SDL renderer must be valid.
Returns
true if the screenshot generation was successful, false otherwise.

Definition at line 7253 of file game.cpp.

7254{
7255 popup( _( "This binary was not compiled with tiles support." ) );
7256 return false;
7257}

References _, and popup().

◆ temp_exit_fullscreen()

void game::temp_exit_fullscreen ( )

Definition at line 552 of file game.cpp.

553{
554 if( fullscreen ) {
555 was_fullscreen = true;
557 } else {
558 was_fullscreen = false;
559 }
560}

References fullscreen, toggle_fullscreen(), and was_fullscreen.

Referenced by list_items_monsters(), and look_around().

◆ toggle_debug_hour_timer()

void game::toggle_debug_hour_timer ( )

Definition at line 11297 of file game.cpp.

11298{
11300}

References game::debug_hour_timer::toggle().

Referenced by handle_action(), and look_around().

◆ toggle_fullscreen()

void game::toggle_fullscreen ( )

Definition at line 505 of file game.cpp.

506{
507#if !defined(TILES)
510#else
511 toggle_fullscreen_window();
512#endif
513}

References fullscreen, and mark_main_ui_adaptor_resize().

Referenced by handle_action(), reenter_fullscreen(), and temp_exit_fullscreen().

◆ toggle_gate()

void game::toggle_gate ( const tripoint p)

Definition at line 5252 of file game.cpp.

5253{
5254 gates::toggle_gate( p, u );
5255}
void toggle_gate(const tripoint &pos, player &p)
opens/closes the gate via player's activity
Definition: gates.cpp:236

References gates::toggle_gate(), and u.

◆ toggle_pixel_minimap()

void game::toggle_pixel_minimap ( )

Definition at line 515 of file game.cpp.

516{
517#if defined(TILES)
519 clear_window_area( w_pixel_minimap );
520 }
523#endif // TILES
524}

References mark_main_ui_adaptor_resize(), pixel_minimap_option, and w_pixel_minimap.

Referenced by handle_action(), and look_around().

◆ try_get_left_click_action()

bool game::try_get_left_click_action ( action_id act,
const tripoint mouse_target 
)
private

Definition at line 2400 of file game.cpp.

2401{
2402 bool new_destination = true;
2403 if( !destination_preview.empty() ) {
2404 auto &final_destination = destination_preview.back();
2405 if( final_destination.x == mouse_target.x && final_destination.y == mouse_target.y ) {
2406 // Second click
2407 new_destination = false;
2409 destination_preview.clear();
2411 if( act == ACTION_NULL ) {
2412 // Something went wrong
2414 return false;
2415 }
2416 }
2417 }
2418
2419 if( new_destination ) {
2421 u.get_path_avoid() );
2422 return false;
2423 }
2424
2425 return true;
2426}

References act, ACTION_NULL, Character::clear_destination(), destination_preview, Character::get_next_auto_move_direction(), Character::get_path_avoid(), Character::get_pathfinding_settings(), m, Character::pos(), map::route(), Character::set_destination(), u, tripoint::x, and tripoint::y.

Referenced by handle_action().

◆ try_get_right_click_action()

bool game::try_get_right_click_action ( action_id act,
const tripoint mouse_target 
)
private

Definition at line 2428 of file game.cpp.

2429{
2430 const bool cleared_destination = !destination_preview.empty();
2432 destination_preview.clear();
2433
2434 if( cleared_destination ) {
2435 // Produce no-op if auto-move had just been cleared on this action
2436 // e.g. from a previous single left mouse click. This has the effect
2437 // of right-click canceling an auto-move before it is initiated.
2438 return false;
2439 }
2440
2441 const bool is_adjacent = square_dist( mouse_target.xy(), point( u.posx(), u.posy() ) ) <= 1;
2442 const bool is_self = square_dist( mouse_target.xy(), point( u.posx(), u.posy() ) ) <= 0;
2443 if( const monster *const mon = critter_at<monster>( mouse_target ) ) {
2444 if( !u.sees( *mon ) ) {
2445 add_msg( _( "Nothing relevant here." ) );
2446 return false;
2447 }
2448
2449 if( !u.weapon.is_gun() ) {
2450 add_msg( m_info, _( "You are not wielding a ranged weapon." ) );
2451 return false;
2452 }
2453
2454 // TODO: Add weapon range check. This requires weapon to be reloaded.
2455
2456 act = ACTION_FIRE;
2457 } else if( is_adjacent &&
2458 m.close_door( tripoint( mouse_target.xy(), u.posz() ), !m.is_outside( u.pos() ),
2459 true ) ) {
2460 act = ACTION_CLOSE;
2461 } else if( is_self ) {
2463 } else if( is_adjacent ) {
2465 } else {
2466 add_msg( _( "Nothing relevant here." ) );
2467 return false;
2468 }
2469
2470 return true;
2471}
bool close_door(const tripoint &p, bool inside, bool check_only)
Definition: map.cpp:3963
static bool is_adjacent(const monster &z, const Creature &target)

References _, act, ACTION_CLOSE, ACTION_EXAMINE, ACTION_FIRE, ACTION_PICKUP, add_msg(), Character::clear_destination(), map::close_door(), destination_preview, is_adjacent(), item::is_gun(), map::is_outside(), m, m_info, Character::pos(), Character::posx(), Character::posy(), Character::posz(), Character::sees(), square_dist(), u, Character::weapon, and tripoint::xy().

Referenced by handle_action().

◆ unload_npcs()

void game::unload_npcs ( )
private

Unloads all NPCs.

If you call this you must later call load_npcs, lest caches get rather confused. The tests used to call this a lot when they shouldn't. It is now private to reduce the chance of similar problems in the future.

Definition at line 967 of file game.cpp.

968{
969 for( const auto &npc : active_npc ) {
970 npc->on_unload();
971 }
972
973 active_npc.clear();
974}
void on_unload()
Do some cleanup and caching as npc is being unloaded from map.
Definition: npc.cpp:2645

References active_npc, and npc::on_unload().

Referenced by place_player_overmap(), and reload_npcs().

◆ unserialize()

void game::unserialize ( std::istream &  fin)

Definition at line 167 of file savegame.cpp.

168{
169 chkversion( fin );
170 int tmpturn = 0;
171 int tmpcalstart = 0;
172 int tmprun = 0;
173 tripoint lev;
174 point com;
175 JsonIn jsin( fin );
176 try {
177 JsonObject data = jsin.get_object();
178
179 data.read( "turn", tmpturn );
180 data.read( "calendar_start", tmpcalstart );
182 calendar_config._initial_season = static_cast<season_type>( data.get_int( "initial_season",
183 static_cast<int>( SPRING ) ) );
184 // 0.E stable
185 if( savegame_loading_version < 26 ) {
186 tmpturn *= 6;
187 tmpcalstart *= 6;
188 }
191 tmpcalstart );
192
193 if( !data.read( "game_start", calendar_config._start_of_game ) ) {
195 }
196
197 data.read( "auto_travel_mode", auto_travel_mode );
198 data.read( "run_mode", tmprun );
199 data.read( "mostseen", mostseen );
200 data.read( "levx", lev.x );
201 data.read( "levy", lev.y );
202 data.read( "levz", lev.z );
203 data.read( "om_x", com.x );
204 data.read( "om_y", com.y );
205
206 load_map(
207 tripoint( lev.x + com.x * OMAPX * 2, lev.y + com.y * OMAPY * 2, lev.z ),
208 /*pump_events=*/true
209 );
210
211 safe_mode = static_cast<safe_mode_type>( tmprun );
212 if( get_option<bool>( "SAFEMODE" ) && safe_mode == SAFE_MODE_OFF ) {
214 }
215
216 std::string linebuff;
217 std::string linebuf;
218 if( data.read( "grscent", linebuf ) && data.read( "typescent", linebuff ) ) {
219 scent.deserialize( linebuf );
220 scent.deserialize( linebuff, true );
221 } else {
222 scent.reset();
223 }
224 data.read( "active_monsters", *critter_tracker );
225
226 coming_to_stairs.clear();
227 for( auto elem : data.get_array( "stair_monsters" ) ) {
228 monster stairtmp;
229 elem.read( stairtmp );
230 coming_to_stairs.push_back( stairtmp );
231 }
232
233 if( data.has_object( "kill_tracker" ) ) {
234 data.read( "kill_tracker", *kill_tracker_ptr );
235 } else {
236 // Legacy support for when kills were stored directly in game
237 std::map<mtype_id, int> kills;
238 std::vector<std::string> npc_kills;
239 for( const JsonMember member : data.get_object( "kills" ) ) {
240 kills[mtype_id( member.name() )] = member.get_int();
241 }
242
243 for( const std::string npc_name : data.get_array( "npc_kills" ) ) {
244 npc_kills.push_back( npc_name );
245 }
246
247 kill_tracker_ptr->reset( kills, npc_kills );
248 }
249
250 data.read( "player", u );
252 data.read( "stats_tracker", *stats_tracker_ptr );
253 data.read( "achievements_tracker", *achievements_tracker_ptr );
254 data.read( "token_provider", token_provider_ptr );
256 Messages::deserialize( data );
257
258 } catch( const JsonError &jsonerr ) {
259 debugmsg( "Bad save json\n%s", jsonerr.c_str() );
260 return;
261 }
262}
season_type
Real world seasons.
Definition: calendar.h:17
Represents a member of a JsonObject.
Definition: json.h:1249
JsonObject get_object(const std::string &name) const
Definition: json.cpp:361
bool has_object(const std::string &name) const
Definition: json.cpp:425
JsonArray get_array(const std::string &name) const
Definition: json.cpp:332
int get_int(const std::string &name) const
Definition: json.cpp:282
bool read(const std::string &name, T &t, bool throw_on_error=true) const
Definition: json.h:944
void deserialize(const std::string &data, bool is_type=false)
Definition: savegame.cpp:264
safe_mode_type
Definition: game.h:76
static constexpr int OMAPY
static constexpr int OMAPX
Size of the overmap.
void deserialize(const JsonObject &json)
Definition: messages.cpp:330
std::string member
Definition: mapgen.cpp:406
static void chkversion(std::istream &fin)
Definition: savegame.cpp:148
int savegame_loading_version
Definition: savegame.cpp:64

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, achievements_tracker_ptr, auto_travel_mode, JsonError::c_str(), chkversion(), coming_to_stairs, calendar::config, critter_tracker, debugmsg, Messages::deserialize(), scent_map::deserialize(), time_duration::from_turns(), JsonObject::get_array(), JsonObject::get_int(), JsonIn::get_object(), JsonObject::get_object(), JsonObject::has_object(), inp_mngr, kill_tracker_ptr, load_map(), mapgen_defer::member, mostseen, mtype_id, OMAPX, OMAPY, input_manager::pump_events(), JsonObject::read(), scent_map::reset(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, savegame_loading_version, scent, SPRING, stats_tracker_ptr, token_provider_ptr, calendar::turn, calendar::turn_zero, u, point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

Referenced by load().

◆ unserialize_master()

void game::unserialize_master ( std::istream &  fin)

Definition at line 1193 of file savegame.cpp.

1194{
1196 chkversion( fin );
1197 if( savegame_loading_version < 11 ) {
1198 std::unique_ptr<static_popup>popup = std::make_unique<static_popup>();
1199 popup->message(
1200 _( "Cannot find loader for save data in old version %d, attempting to load as current version %d." ),
1204 }
1205 try {
1206 // single-pass parsing example
1207 JsonIn jsin( fin );
1208 jsin.start_object();
1209 while( !jsin.end_object() ) {
1210 std::string name = jsin.get_member_name();
1211 if( name == "next_mission_id" ) {
1212 next_mission_id = jsin.get_int();
1213 } else if( name == "next_npc_id" ) {
1214 next_npc_id.deserialize( jsin );
1215 } else if( name == "active_missions" ) {
1217 } else if( name == "factions" ) {
1218 jsin.read( *faction_manager_ptr );
1219 } else if( name == "seed" ) {
1220 jsin.read( seed );
1221 } else if( name == "weather" ) {
1222 JsonObject w = jsin.get_object();
1223 w.read( "lightning", get_weather().lightning_active );
1224 } else {
1225 // silently ignore anything else
1226 jsin.skip_value();
1227 }
1228 }
1229 } catch( const JsonError &e ) {
1230 debugmsg( "error loading %s: %s", SAVE_MASTER, e.c_str() );
1231 }
1232}
void deserialize(JsonIn &)
static void unserialize_all(JsonIn &jsin)
Definition: savegame.cpp:1183

References _, JsonError::c_str(), chkversion(), debugmsg, character_id::deserialize(), JsonIn::end_object(), faction_manager_ptr, JsonIn::get_int(), JsonIn::get_member_name(), JsonIn::get_object(), get_weather, om_direction::name(), next_mission_id, next_npc_id, popup(), JsonIn::read(), JsonObject::read(), ui_manager::redraw(), refresh_display(), SAVE_MASTER(), savegame_loading_version, savegame_version, seed, JsonIn::skip_value(), JsonIn::start_object(), and mission::unserialize_all().

Referenced by load_master().

◆ update_map() [1/2]

point game::update_map ( int &  x,
int &  y 
)

Definition at line 10757 of file game.cpp.

10758{
10759 point shift;
10760
10761 while( x < HALF_MAPSIZE_X ) {
10762 x += SEEX;
10763 shift.x--;
10764 }
10765 while( x >= HALF_MAPSIZE_X + SEEX ) {
10766 x -= SEEX;
10767 shift.x++;
10768 }
10769 while( y < HALF_MAPSIZE_Y ) {
10770 y += SEEY;
10771 shift.y--;
10772 }
10773 while( y >= HALF_MAPSIZE_Y + SEEY ) {
10774 y -= SEEY;
10775 shift.y++;
10776 }
10777
10778 if( shift == point_zero ) {
10779 // adjust player position
10780 u.setpos( tripoint( x, y, get_levz() ) );
10781 // Update what parts of the world map we can see
10782 // We need this call because even if the map hasn't shifted we may have changed z-level and can now see farther
10783 // TODO: only make this call if we changed z-level
10785 // Not actually shifting the submaps, all the stuff below would do nothing
10786 return point_zero;
10787 }
10788
10789 // this handles loading/unloading submaps that have scrolled on or off the viewport
10790 // NOLINTNEXTLINE(cata-use-named-point-constants)
10791 inclusive_rectangle<point> size_1( point( -1, -1 ), point( 1, 1 ) );
10792 point remaining_shift = shift;
10793 while( remaining_shift != point_zero ) {
10794 point this_shift = clamp( remaining_shift, size_1 );
10795 m.shift( this_shift );
10796 remaining_shift -= this_shift;
10797 }
10798
10799 grid_tracker_ptr->load( m );
10800
10801 // Shift monsters
10802 shift_monsters( tripoint( shift, 0 ) );
10803 const point shift_ms = sm_to_ms_copy( shift );
10804 u.shift_destination( -shift_ms );
10805
10806 // Shift NPCs
10807 for( auto it = active_npc.begin(); it != active_npc.end(); ) {
10808 ( *it )->shift( shift );
10809 if( ( *it )->posx() < 0 - SEEX * 2 || ( *it )->posy() < 0 - SEEX * 2 ||
10810 ( *it )->posx() > SEEX * ( MAPSIZE + 2 ) || ( *it )->posy() > SEEY * ( MAPSIZE + 2 ) ) {
10811 //Remove the npc from the active list. It remains in the overmap list.
10812 ( *it )->on_unload();
10813 it = active_npc.erase( it );
10814 } else {
10815 it++;
10816 }
10817 }
10818
10819 scent.shift( shift_ms );
10820
10821 // Also ensure the player is on current z-level
10822 // get_levz() should later be removed, when there is no longer such a thing
10823 // as "current z-level"
10824 u.setpos( tripoint( x, y, get_levz() ) );
10825
10826 // Only do the loading after all coordinates have been shifted.
10827
10828 // Check for overmap saved npcs that should now come into view.
10829 // Put those in the active list.
10830 load_npcs();
10831
10832 // Make sure map cache is consistent since it may have shifted.
10833 if( m.has_zlevels() ) {
10834 for( int zlev = -OVERMAP_DEPTH; zlev <= OVERMAP_HEIGHT; ++zlev ) {
10835 m.invalidate_map_cache( zlev );
10836 }
10837 } else {
10839 }
10841
10842 // Spawn monsters if appropriate
10843 // This call will generate new monsters in addition to loading, so it's placed after NPC loading
10844 m.spawn_monsters( false ); // Static monsters
10845
10846 // Update what parts of the world map we can see
10848
10849 return shift;
10850}
void shift_destination(const point &shift)
void shift_monsters(const tripoint &shift)
Shift all active monsters, the shift vector is the number of shifted submaps.
Definition: game.cpp:11126
void shift(const point &s)
Shift the map along the vector s.
Definition: map.cpp:6766
void shift(const point &sm_shift)
Definition: scent_map.cpp:82
point sm_to_ms_copy(const point &p)
static constexpr int HALF_MAPSIZE_Y
static constexpr int HALF_MAPSIZE_X

References active_npc, map::build_map_cache(), clamp(), get_levz(), grid_tracker_ptr, HALF_MAPSIZE_X, HALF_MAPSIZE_Y, map::has_zlevels(), map::invalidate_map_cache(), load_npcs(), m, MAPSIZE, OVERMAP_DEPTH, OVERMAP_HEIGHT, point_zero, scent, SEEX, SEEY, Character::setpos(), map::shift(), scent_map::shift(), Character::shift_destination(), shift_monsters(), sm_to_ms_copy(), map::spawn_monsters(), u, update_overmap_seen(), point::x, and point::y.

◆ update_map() [2/2]

point game::update_map ( player p)

Definition at line 10751 of file game.cpp.

10752{
10753 point p2( p.posx(), p.posy() );
10754 return update_map( p2.x, p2.y );
10755}

References Character::posx(), Character::posy(), update_map(), point::x, and point::y.

Referenced by fling_creature(), load(), place_player(), start_game(), update_map(), and vertical_move().

◆ update_overmap_seen()

void game::update_overmap_seen ( )

Definition at line 10852 of file game.cpp.

10853{
10854 const tripoint_abs_omt ompos = u.global_omt_location();
10855 const int dist = u.overmap_sight_range( light_level( u.posz() ) );
10856 const int dist_squared = dist * dist;
10857 // We can always see where we're standing
10858 overmap_buffer.set_seen( ompos, true );
10859 for( const tripoint_abs_omt &p : points_in_radius( ompos, dist ) ) {
10860 const point_rel_omt delta = p.xy() - ompos.xy();
10861 const int h_squared = delta.x() * delta.x() + delta.y() * delta.y();
10862 if( trigdist && h_squared > dist_squared ) {
10863 continue;
10864 }
10865 if( delta == point_rel_omt() ) {
10866 // 1. This case is already handled outside of the loop
10867 // 2. Calculating multiplier would cause division by zero
10868 continue;
10869 }
10870 // If circular distances are enabled, scale overmap distances by the diagonality of the sight line.
10871 point abs_delta = delta.raw().abs();
10872 int max_delta = std::max( abs_delta.x, abs_delta.y );
10873 const float multiplier = trigdist ? std::sqrt( h_squared ) / max_delta : 1;
10874 const std::vector<tripoint_abs_omt> line = line_to( ompos, p );
10875 float sight_points = dist;
10876 for( auto it = line.begin();
10877 it != line.end() && sight_points >= 0; ++it ) {
10878 const oter_id &ter = overmap_buffer.ter( *it );
10879 sight_points -= static_cast<int>( ter->get_see_cost() ) * multiplier;
10880 }
10881 if( sight_points >= 0 ) {
10882 tripoint_abs_omt seen( p );
10883 do {
10884 overmap_buffer.set_seen( seen, true );
10885 --seen.z();
10886 } while( seen.z() >= 0 );
10887 }
10888 }
10889}
bool trigdist
Circular distances.
int overmap_sight_range(int light_level) const
Returns the distance the player can see on the overmap.
Definition: character.cpp:771
constexpr Point & raw()
Definition: coordinates.h:111
void set_seen(const tripoint_abs_omt &p, bool seen=true)
coords::coord_point< point, coords::origin::relative, coords::omt > point_rel_omt
Definition: coordinates.h:478
tripoint_range< Tripoint > points_in_radius(const Tripoint &center, const int radius, const int radiusz=0)
Definition: map_iterator.h:125
unsigned char get_see_cost() const
Definition: omdata.h:230

References oter_t::get_see_cost(), Character::global_omt_location(), light_level(), line(), line_to(), overmap_buffer, Character::overmap_sight_range(), points_in_radius(), Character::posz(), coords::coord_point< Point, Origin, Scale >::raw(), overmapbuffer::set_seen(), overmapbuffer::ter(), trigdist, u, coords::coord_point< Point, Origin, Scale >::x(), point::x, coords::coord_point< Point, Origin, Scale >::xy(), coords::coord_point< Point, Origin, Scale >::y(), point::y, and coords::coord_point< Point, Origin, Scale >::z().

Referenced by place_player_overmap(), and update_map().

◆ update_stair_monsters()

void game::update_stair_monsters ( )
private
Dodge reduces chance of being downed when pushed off the stairs

Definition at line 10904 of file game.cpp.

10905{
10906 // Search for the stairs closest to the player.
10907 std::vector<int> stairx;
10908 std::vector<int> stairy;
10909 std::vector<int> stairdist;
10910
10911 const bool from_below = monstairz < get_levz();
10912
10913 if( coming_to_stairs.empty() ) {
10914 return;
10915 }
10916
10917 if( m.has_zlevels() ) {
10918 debugmsg( "%d monsters coming to stairs on a map with z-levels",
10919 coming_to_stairs.size() );
10920 coming_to_stairs.clear();
10921 }
10922
10923 for( const tripoint &dest : m.points_on_zlevel( u.posz() ) ) {
10924 if( ( from_below && m.has_flag( "GOES_DOWN", dest ) ) ||
10925 ( !from_below && m.has_flag( "GOES_UP", dest ) ) ) {
10926 stairx.push_back( dest.x );
10927 stairy.push_back( dest.y );
10928 stairdist.push_back( rl_dist( dest, u.pos() ) );
10929 }
10930 }
10931 if( stairdist.empty() ) {
10932 return; // Found no stairs?
10933 }
10934
10935 // Find closest stairs.
10936 size_t si = 0;
10937 for( size_t i = 0; i < stairdist.size(); i++ ) {
10938 if( stairdist[i] < stairdist[si] ) {
10939 si = i;
10940 }
10941 }
10942
10943 // Find up to 4 stairs for distance stairdist[si] +1
10944 std::vector<int> nearest;
10945 nearest.push_back( si );
10946 for( size_t i = 0; i < stairdist.size() && nearest.size() < 4; i++ ) {
10947 if( ( i != si ) && ( stairdist[i] <= stairdist[si] + 1 ) ) {
10948 nearest.push_back( i );
10949 }
10950 }
10951 // Randomize the stair choice
10952 si = random_entry_ref( nearest );
10953
10954 // Attempt to spawn zombies.
10955 for( size_t i = 0; i < coming_to_stairs.size(); i++ ) {
10956 point mpos( stairx[si], stairy[si] );
10957 monster &critter = coming_to_stairs[i];
10958 const tripoint dest {
10959 mpos, g->get_levz()
10960 };
10961
10962 // We might be not be visible.
10963 if( ( critter.posx() < 0 - ( MAPSIZE_X ) / 6 ||
10964 critter.posy() < 0 - ( MAPSIZE_Y ) / 6 ||
10965 critter.posx() > ( MAPSIZE_X * 7 ) / 6 ||
10966 critter.posy() > ( MAPSIZE_Y * 7 ) / 6 ) ) {
10967 continue;
10968 }
10969
10970 critter.staircount -= 4;
10971 // Let the player know zombies are trying to come.
10972 if( u.sees( dest ) ) {
10973 std::string dump;
10974 if( critter.staircount > 4 ) {
10975 dump += string_format( _( "You see a %s on the stairs" ), critter.name() );
10976 } else {
10977 if( critter.staircount > 0 ) {
10978 dump += ( from_below ?
10979 //~ The <monster> is almost at the <bottom/top> of the <terrain type>!
10980 string_format( _( "The %1$s is almost at the top of the %2$s!" ),
10981 critter.name(),
10982 m.tername( dest ) ) :
10983 string_format( _( "The %1$s is almost at the bottom of the %2$s!" ),
10984 critter.name(),
10985 m.tername( dest ) ) );
10986 }
10987 }
10988
10989 add_msg( m_warning, dump );
10990 } else {
10992 _( "a sound nearby from the stairs!" ), true, "misc", "stairs_movement" );
10993 }
10994
10995 if( critter.staircount > 0 ) {
10996 continue;
10997 }
10998
10999 if( is_empty( dest ) ) {
11000 critter.spawn( dest );
11001 critter.staircount = 0;
11002 place_critter_at( make_shared_fast<monster>( critter ), dest );
11003 if( u.sees( dest ) ) {
11004 if( !from_below ) {
11005 add_msg( m_warning, _( "The %1$s comes down the %2$s!" ),
11006 critter.name(),
11007 m.tername( dest ) );
11008 } else {
11009 add_msg( m_warning, _( "The %1$s comes up the %2$s!" ),
11010 critter.name(),
11011 m.tername( dest ) );
11012 }
11013 }
11014 coming_to_stairs.erase( coming_to_stairs.begin() + i );
11015 continue;
11016 } else if( u.pos() == dest ) {
11017 // Monster attempts to push player of stairs
11019 int tries = 0;
11020
11021 // the critter is now right on top of you and will attack unless
11022 // it can find a square to push you into with one of his tries.
11023 const int creature_push_attempts = 9;
11024 const int player_throw_resist_chance = 3;
11025
11026 critter.spawn( dest );
11027 while( tries < creature_push_attempts ) {
11028 tries++;
11029 push.x = rng( -1, 1 );
11030 push.y = rng( -1, 1 );
11031 point ipos( mpos + push );
11032 tripoint pos( ipos, get_levz() );
11033 if( ( push.x != 0 || push.y != 0 ) && !critter_at( pos ) &&
11034 critter.can_move_to( pos ) ) {
11035 bool resiststhrow = ( u.is_throw_immune() ) ||
11037 if( resiststhrow && one_in( player_throw_resist_chance ) ) {
11038 u.moves -= 25; // small charge for avoiding the push altogether
11039 add_msg( _( "The %s fails to push you back!" ),
11040 critter.name() );
11041 return; //judo or leg brace prevent you from getting pushed at all
11042 }
11043 // Not accounting for tentacles latching on, so..
11044 // Something is about to happen, lets charge half a move
11045 u.moves -= 50;
11046 if( resiststhrow && ( u.is_throw_immune() ) ) {
11047 //we have a judoka who isn't getting pushed but counterattacking now.
11048 mattack::thrown_by_judo( &critter );
11049 return;
11050 }
11051 std::string msg;
11052 ///\EFFECT_DODGE reduces chance of being downed when pushed off the stairs
11053 if( !( resiststhrow ) && ( u.get_dodge() + rng( 0, 3 ) < 12 ) ) {
11054 // dodge 12 - never get downed
11055 // 11.. avoid 75%; 10.. avoid 50%; 9.. avoid 25%
11056 u.add_effect( effect_downed, 2_turns );
11057 msg = _( "The %s pushed you back hard!" );
11058 } else {
11059 msg = _( "The %s pushed you back!" );
11060 }
11061 add_msg( m_warning, msg.c_str(), critter.name() );
11062 u.setx( u.posx() + push.x );
11063 u.sety( u.posy() + push.y );
11064 return;
11065 }
11066 }
11068 _( "The %s tried to push you back but failed! It attacks you!" ),
11069 critter.name() );
11070 critter.melee_attack( u );
11071 u.moves -= 50;
11072 return;
11073 } else if( monster *const mon_ptr = critter_at<monster>( dest ) ) {
11074 // Monster attempts to displace a monster from the stairs
11075 monster &other = *mon_ptr;
11076 critter.spawn( dest );
11077
11078 // the critter is now right on top of another and will push it
11079 // if it can find a square to push it into inside of his tries.
11080 const int creature_push_attempts = 9;
11081 const int creature_throw_resist = 4;
11082
11083 int tries = 0;
11084 point push2;
11085 while( tries < creature_push_attempts ) {
11086 tries++;
11087 push2.x = rng( -1, 1 );
11088 push2.y = rng( -1, 1 );
11089 point ipos2( mpos + push2 );
11090 tripoint pos( ipos2, get_levz() );
11091 if( ( push2.x == 0 && push2.y == 0 ) || ( ( ipos2.x == u.posx() ) && ( ipos2.y == u.posy() ) ) ) {
11092 continue;
11093 }
11094 if( !critter_at( pos ) && other.can_move_to( pos ) ) {
11095 other.setpos( tripoint( ipos2, get_levz() ) );
11096 other.moves -= 50;
11097 std::string msg;
11098 if( one_in( creature_throw_resist ) ) {
11099 other.add_effect( effect_downed, 2_turns );
11100 msg = _( "The %1$s pushed the %2$s hard." );
11101 } else {
11102 msg = _( "The %1$s pushed the %2$s." );
11103 }
11104 add_msg( m_neutral, msg, critter.name(), other.name() );
11105 return;
11106 }
11107 }
11108 return;
11109 }
11110 }
11111}
void setx(int x)
Definition: character.h:788
void sety(int y)
Definition: character.h:791
bool is_throw_immune() const
Returns true if the player is immune to throws.
float get_dodge() const override
Definition: melee.cpp:812
int monstairz
Definition: game.h:1010
tripoint_range< tripoint > points_on_zlevel() const
Yields a range of all points that are contained in the map and have the z-level of this map (abs_sub)...
Definition: map.cpp:8626
bool can_move_to(const tripoint &p) const
Checks whether we can move to/through p.
Definition: monmove.cpp:258
int posy() const override
Definition: monster.h:501
void melee_attack(Creature &target)
Definition: monster.cpp:1390
int staircount
Definition: monster.h:512
void spawn(const tripoint &p)
Definition: monster.cpp:482
int posx() const override
Definition: monster.h:498
bool thrown_by_judo(monster *z)
Definition: monattack.cpp:4673
std::enable_if<!is_std_array< C >::value, constV & >::type random_entry_ref(const C &container)
Same as above, but with a statically allocated default value (using the default constructor).
Definition: rng.h:149

References _, Creature::add_effect(), add_msg(), monster::can_move_to(), coming_to_stairs, critter_at(), debugmsg, effect_downed, g, Character::get_dodge(), get_levz(), map::has_flag(), Character::has_trait(), map::has_zlevels(), is_empty(), Character::is_throw_immune(), m, m_neutral, m_warning, MAPSIZE_X, MAPSIZE_Y, monster::melee_attack(), monstairz, sounds::movement, Creature::moves, monster::name(), one_in(), other, place_critter_at(), point_north_west, map::points_on_zlevel(), Character::pos(), Character::posx(), monster::posx(), Character::posy(), monster::posy(), Character::posz(), monexamine::push(), random_entry_ref(), rl_dist(), rng(), Character::sees(), Character::setx(), Character::sety(), sounds::sound(), monster::spawn(), monster::staircount, string_format(), map::tername(), mattack::thrown_by_judo(), trait_LEG_TENT_BRACE, u, point::x, and point::y.

Referenced by do_turn(), and vertical_move().

◆ update_zombie_pos()

bool game::update_zombie_pos ( const monster critter,
const tripoint pos 
)

Redirects to the creature_tracker update_pos() function.

Definition at line 4853 of file game.cpp.

4854{
4855 return critter_tracker->update_pos( critter, pos );
4856}

References critter_tracker.

◆ use_computer()

void game::use_computer ( const tripoint p)

Checks to see if a player can use a computer (not illiterate, etc.) and uses if able.

Definition at line 4636 of file game.cpp.

4637{
4638 if( u.has_trait( trait_id( "ILLITERATE" ) ) ) {
4639 add_msg( m_info, _( "You can not read a computer screen!" ) );
4640 return;
4641 }
4642 if( u.is_blind() ) {
4643 // we don't have screen readers in game
4644 add_msg( m_info, _( "You can not see a computer screen!" ) );
4645 return;
4646 }
4647 if( u.has_trait( trait_id( "HYPEROPIC" ) ) && !u.worn_with_flag( "FIX_FARSIGHT" ) &&
4648 !u.has_effect( effect_contacts ) && !u.has_bionic( bionic_id( "bio_eye_optic" ) ) ) {
4649 add_msg( m_info, _( "You'll need to put on reading glasses before you can see the screen." ) );
4650 return;
4651 }
4652
4653 computer *used = m.computer_at( p );
4654
4655 if( used == nullptr ) {
4656 if( m.has_flag( "CONSOLE", p ) ) { //Console without map data
4657 add_msg( m_bad, _( "The console doesn't display anything coherent." ) );
4658 } else {
4659 debugmsg( "Tried to use computer at %s - none there", p.to_string() );
4660 }
4661 return;
4662 }
4663
4664 computer_session( *used ).use();
4665}
void use()
Handles player use of a computer.
computer * computer_at(const tripoint &p)
Definition: map.cpp:5542
static const efftype_id effect_contacts("contacts")

References _, add_msg(), map::computer_at(), debugmsg, effect_contacts, Character::has_bionic(), Creature::has_effect(), map::has_flag(), Character::has_trait(), Character::is_blind(), m, m_bad, m_info, tripoint::to_string(), u, computer_session::use(), and Character::worn_with_flag().

Referenced by examine().

◆ validate_camps()

void game::validate_camps ( )

validate camps to ensure they are on the overmap list

Definition at line 2061 of file game.cpp.

2062{
2063 basecamp camp = m.hoist_submap_camp( u.pos() );
2064 if( camp.is_valid() ) {
2065 overmap_buffer.add_camp( camp );
2067 } else if( camp.camp_omt_pos() != tripoint_abs_omt() ) {
2068 std::string camp_name = _( "Faction Camp" );
2069 camp.set_name( camp_name );
2070 overmap_buffer.add_camp( camp );
2072 }
2073}
bool is_valid() const
Definition: basecamp.h:125
void set_name(const std::string &new_name)
Definition: basecamp.cpp:575
tripoint_abs_omt camp_omt_pos() const
Definition: basecamp.h:134
basecamp hoist_submap_camp(const tripoint &p)
Definition: map.cpp:5573
void remove_submap_camp(const tripoint &)
Definition: map.cpp:5568
void add_camp(const basecamp &camp)
Add Basecamp to overmapbuffer.

References _, overmapbuffer::add_camp(), basecamp::camp_omt_pos(), map::hoist_submap_camp(), basecamp::is_valid(), m, overmap_buffer, Character::pos(), map::remove_submap_camp(), basecamp::set_name(), and u.

Referenced by load().

◆ validate_linked_vehicles()

void game::validate_linked_vehicles ( )

validate towed vehicles so they get linked up again after a load

Definition at line 2003 of file game.cpp.

2004{
2005 for( auto &veh : m.get_vehicles() ) {
2006 vehicle *v = veh.v;
2009 if( other_v ) {
2010 // the other vehicle is towing us.
2011 v->tow_data.set_towing( other_v, v );
2013 }
2014 }
2015 }
2016}
tripoint other_towing_point
Definition: vehicle.h:167
bool set_towing(vehicle *tower_veh, vehicle *towed_veh)
Definition: vehicle.cpp:6117
towing_data tow_data
Definition: vehicle.h:1944

References map::get_vehicles(), m, towing_data::other_towing_point, towing_data::set_towing(), vehicle::tow_data, tripoint_zero, map::veh_at(), and veh_pointer_or_null().

Referenced by load().

◆ validate_mounted_npcs()

void game::validate_mounted_npcs ( )

Definition at line 2018 of file game.cpp.

2019{
2020 for( monster &m : all_monsters() ) {
2021 if( m.has_effect( effect_ridden ) && m.mounted_player_id.is_valid() ) {
2022 player *mounted_pl = g->critter_by_id<player>( m.mounted_player_id );
2023 if( !mounted_pl ) {
2024 // Target no longer valid.
2025 m.mounted_player_id = character_id();
2026 m.remove_effect( effect_ridden );
2027 continue;
2028 }
2029 mounted_pl->mounted_creature = shared_from( m );
2030 mounted_pl->setpos( m.pos() );
2031 mounted_pl->add_effect( effect_riding, 1_turns, num_bp );
2032 m.mounted_player = mounted_pl;
2033 }
2034 }
2035}

References Creature::add_effect(), all_monsters(), character_id, effect_ridden, effect_riding, g, m, Character::mounted_creature, num_bp, Character::setpos(), and shared_from().

Referenced by load(), and vertical_shift().

◆ validate_npc_followers()

void game::validate_npc_followers ( )

validate list of followers to account for overmap buffers

Definition at line 2037 of file game.cpp.

2038{
2039 // Make sure visible followers are in the list.
2040 const std::vector<npc *> visible_followers = get_npcs_if( [&]( const npc & guy ) {
2041 return guy.is_player_ally();
2042 } );
2043 for( npc *guy : visible_followers ) {
2044 update_faction_api( guy );
2045 add_npc_follower( guy->getID() );
2046 }
2047 // Make sure overmapbuffered NPC followers are in the list.
2048 for( const auto &temp_guy : overmap_buffer.get_npcs_near_player( 300 ) ) {
2049 npc *guy = temp_guy.get();
2050 if( guy->is_player_ally() ) {
2051 update_faction_api( guy );
2052 add_npc_follower( guy->getID() );
2053 }
2054 }
2055 // Make sure that serialized player followers sync up with game list
2056 for( const auto &temp_id : u.follower_ids ) {
2057 add_npc_follower( temp_id );
2058 }
2059}
void add_npc_follower(const character_id &id)
Add follower id to set of followers.
Definition: game.cpp:1983
static void update_faction_api(npc *guy)
Definition: game.cpp:1995

References add_npc_follower(), player::follower_ids, get_npcs_if(), overmapbuffer::get_npcs_near_player(), Character::getID(), npc::is_player_ally(), overmap_buffer, u, and update_faction_api().

Referenced by load().

◆ vertical_move()

void game::vertical_move ( int  z,
bool  force,
bool  peeking = false 
)

Moves the player vertically.

If force == true then they are falling. If peeking == true, forbids some exotic movement options

Strength increases breath-holding capacity while diving Dexterity increases chance of moving past monsters on stairs Dodge increases chance of moving past monsters on stairs Strength increases chance of moving past monsters on stairs Melee increases chance of moving past monsters on stairs

Definition at line 10078 of file game.cpp.

10079{
10080 if( u.is_mounted() ) {
10081 auto mons = u.mounted_creature.get();
10082 if( mons->has_flag( MF_RIDEABLE_MECH ) ) {
10083 if( !mons->check_mech_powered() ) {
10084 add_msg( m_bad, _( "Your %s refuses to move as its batteries have been drained." ),
10085 mons->get_name() );
10086 return;
10087 }
10088 }
10089 }
10090
10091 // > and < are used for diving underwater.
10092 if( m.has_flag( "SWIMMABLE", u.pos() ) && m.has_flag( TFLAG_DEEP_WATER, u.pos() ) ) {
10093 if( movez == -1 ) {
10094 if( u.is_underwater() ) {
10095 add_msg( m_info, _( "You are already underwater!" ) );
10096 return;
10097 }
10098 if( u.worn_with_flag( "FLOTATION" ) ) {
10099 add_msg( m_info, _( "You can't dive while wearing a flotation device." ) );
10100 return;
10101 }
10102 u.set_underwater( true );
10103 ///\EFFECT_STR increases breath-holding capacity while diving
10104 u.oxygen = 30 + 2 * u.str_cur;
10105 add_msg( _( "You dive underwater!" ) );
10106 } else {
10107 if( u.swim_speed() < 500 || u.shoe_type_count( itype_swim_fins ) ) {
10108 u.set_underwater( false );
10109 add_msg( _( "You surface." ) );
10110 } else {
10111 add_msg( m_info, _( "You try to surface but can't!" ) );
10112 }
10113 }
10114 u.moves -= 100;
10115 return;
10116 }
10117
10118 // Force means we're going down, even if there's no staircase, etc.
10119 bool climbing = false;
10120 int move_cost = 100;
10121 tripoint stairs( u.posx(), u.posy(), u.posz() + movez );
10122 if( m.has_zlevels() && !force && movez == 1 && !m.has_flag( "GOES_UP", u.pos() ) ) {
10123 // Climbing
10124 if( m.has_floor_or_support( stairs ) ) {
10125 add_msg( m_info, _( "You can't climb here - there's a ceiling above your head." ) );
10126 return;
10127 }
10128
10129 std::vector<tripoint> pts;
10130 for( const auto &pt : m.points_in_radius( stairs, 1 ) ) {
10131 if( m.passable( pt ) &&
10132 m.has_floor_or_support( pt ) ) {
10133 pts.push_back( pt );
10134 }
10135 }
10136
10137 const int cost = map_funcs::climbing_cost( m, u.pos(), stairs );
10138
10139 if( cost == 0 ) {
10140 if( u.has_trait( trait_WEB_ROPE ) ) {
10141 if( pts.empty() ) {
10142 add_msg( m_info, _( "There is nothing above you that you can attach a web to." ) );
10143 } else if( can_use_mutation_warn( trait_WEB_ROPE, u ) ) {
10144 if( g->m.move_cost( u.pos() ) != 2 && g->m.move_cost( u.pos() ) != 3 ) {
10145 add_msg( m_info, _( "You can't spin a web rope there." ) );
10146 } else if( g->m.has_furn( u.pos() ) ) {
10147 add_msg( m_info, _( "There is already furniture at that location." ) );
10148 } else {
10149 if( query_yn( "Spin a rope and climb?" ) ) {
10150 add_msg( m_good, _( "You spin a rope of web." ) );
10151 g->m.furn_set( u.pos(), furn_str_id( "f_rope_up_web" ) );
10152 u.mod_moves( to_turns<int>( 2_seconds ) );
10154 vertical_move( movez, force, peeking );
10155 }
10156 }
10157 }
10158
10159 } else {
10160 add_msg( m_info, _( "You can't climb here - you need walls and/or furniture to brace against." ) );
10161
10162 }
10163 return;
10164
10165 }
10166
10167 if( cost <= 0 || pts.empty() ) {
10168 add_msg( m_info,
10169 _( "You can't climb here - there is no terrain above you that would support your weight." ) );
10170 return;
10171 } else {
10172 // TODO: Make it an extended action
10173 climbing = true;
10174 move_cost = cost;
10175
10177 if( !pnt ) {
10178 return;
10179 }
10180 stairs = *pnt;
10181 }
10182 }
10183
10184 if( !force && movez == -1 && !m.has_flag( "GOES_DOWN", u.pos() ) ) {
10185 add_msg( m_info, _( "You can't go down here!" ) );
10186 return;
10187 } else if( !climbing && !force && movez == 1 && !m.has_flag( "GOES_UP", u.pos() ) ) {
10188 add_msg( m_info, _( "You can't go up here!" ) );
10189 return;
10190 }
10191
10192 if( force ) {
10193 // Let go of a grabbed cart.
10194 u.grab( OBJECT_NONE );
10195 } else if( u.grab_point != tripoint_zero ) {
10196 add_msg( m_info, _( "You can't drag things up and down stairs." ) );
10197 return;
10198 }
10199
10200 // Because get_levz takes z-value from the map, it will change when vertical_shift (m.has_zlevels() == true)
10201 // is called or when the map is loaded on new z-level (== false).
10202 // This caches the z-level we start the movement on (current) and the level we're want to end.
10203 const int z_before = get_levz();
10204 const int z_after = get_levz() + movez;
10205 if( z_after < -OVERMAP_DEPTH || z_after > OVERMAP_HEIGHT ) {
10206 debugmsg( "Tried to move outside allowed range of z-levels" );
10207 return;
10208 }
10209
10210 if( !u.move_effects( false ) ) {
10211 return;
10212 }
10213
10214 // Check if there are monsters are using the stairs.
10215 bool slippedpast = false;
10216 if( !m.has_zlevels() && !coming_to_stairs.empty() && !force ) {
10217 // TODO: Allow travel if zombie couldn't reach stairs, but spawn him when we go up.
10218 add_msg( m_warning, _( "You try to use the stairs. Suddenly you are blocked by a %s!" ),
10219 coming_to_stairs[0].name() );
10220 // Roll.
10221 ///\EFFECT_DEX increases chance of moving past monsters on stairs
10222
10223 ///\EFFECT_DODGE increases chance of moving past monsters on stairs
10224 int dexroll = dice( 6, u.dex_cur + u.get_skill_level( skill_dodge ) * 2 );
10225 ///\EFFECT_STR increases chance of moving past monsters on stairs
10226
10227 ///\EFFECT_MELEE increases chance of moving past monsters on stairs
10228 int strroll = dice( 3, u.str_cur + u.get_skill_level( skill_melee ) * 1.5 );
10229 if( coming_to_stairs.size() > 4 ) {
10230 add_msg( _( "The are a lot of them on the %s!" ), m.tername( u.pos() ) );
10231 dexroll /= 4;
10232 strroll /= 2;
10233 } else if( coming_to_stairs.size() > 1 ) {
10234 add_msg( m_warning, _( "There's something else behind it!" ) );
10235 dexroll /= 2;
10236 }
10237
10238 if( dexroll < 14 || strroll < 12 ) {
10240 u.moves -= 100;
10241 return;
10242 }
10243
10244 add_msg( _( "You manage to slip past!" ) );
10245 slippedpast = true;
10246 u.moves -= 100;
10247 }
10248
10249 // Shift the map up or down
10250
10251 std::unique_ptr<map> tmp_map_ptr;
10252 if( !m.has_zlevels() ) {
10253 tmp_map_ptr = std::make_unique<map>();
10254 }
10255
10256 map &maybetmp = m.has_zlevels() ? m : *( tmp_map_ptr.get() );
10257 if( m.has_zlevels() ) {
10258 // We no longer need to shift the map here! What joy
10259 } else {
10260 maybetmp.load( tripoint( get_levx(), get_levy(), z_after ), false );
10261 }
10262
10263 // Find the corresponding staircase
10264 bool rope_ladder = false;
10265 // TODO: Remove the stairfinding, make the mapgen gen aligned maps
10266 if( !force && !climbing ) {
10267 const cata::optional<tripoint> pnt = find_or_make_stairs( maybetmp, z_after, rope_ladder, peeking );
10268 if( !pnt ) {
10269 return;
10270 }
10271 stairs = *pnt;
10272 }
10273
10274 if( !force ) {
10275 monstairz = z_before;
10276 }
10277 // Save all monsters that can reach the stairs, remove them from the tracker,
10278 // then despawn the remaining monsters. Because it's a vertical shift, all
10279 // monsters are out of the bounds of the map and will despawn.
10280 shared_ptr_fast<monster> stored_mount;
10281 if( u.is_mounted() && !m.has_zlevels() ) {
10282 // Store a *copy* of the mount, so we can remove the original monster instance
10283 // from the tracker before the map shifts.
10284 // Map shifting would otherwise just despawn the mount and would later respawn it.
10285 stored_mount = make_shared_fast<monster>( *u.mounted_creature );
10287 }
10288 if( !m.has_zlevels() ) {
10289 const tripoint to = u.pos();
10290 for( monster &critter : all_monsters() ) {
10291 // if its a ladder instead of stairs - most zombies can't climb that.
10292 // unless that have a special flag to allow them to do so.
10293 if( ( m.has_flag( "DIFFICULT_Z", u.pos() ) && !critter.climbs() ) ||
10294 critter.has_effect( effect_ridden ) ||
10295 critter.has_effect( effect_tied ) ) {
10296 continue;
10297 }
10298 int turns = critter.turns_to_reach( to.xy() );
10299 if( turns < 10 && coming_to_stairs.size() < 8 && critter.will_reach( to.xy() )
10300 && !slippedpast ) {
10301 critter.staircount = 10 + turns;
10302 critter.on_unload();
10303 coming_to_stairs.push_back( critter );
10304 remove_zombie( critter );
10305 }
10306 }
10307 auto mons = critter_tracker->find( g->u.pos() );
10308 if( mons != nullptr ) {
10309 critter_tracker->remove( *mons );
10310 }
10311 shift_monsters( tripoint( 0, 0, movez ) );
10312 }
10313
10314 std::vector<shared_ptr_fast<npc>> npcs_to_bring;
10315 std::vector<monster *> monsters_following;
10316 if( !m.has_zlevels() && std::abs( movez ) == 1 ) {
10317 std::copy_if( active_npc.begin(), active_npc.end(), back_inserter( npcs_to_bring ),
10318 [this]( const shared_ptr_fast<npc> &np ) {
10319 return np->is_walking_with() && !np->is_mounted() && !np->in_sleep_state() &&
10320 rl_dist( np->pos(), u.pos() ) < 2;
10321 } );
10322 }
10323
10324 if( m.has_zlevels() && std::abs( movez ) == 1 ) {
10325 bool ladder = m.has_flag( "DIFFICULT_Z", u.pos() );
10326 for( monster &critter : all_monsters() ) {
10327 if( ladder && !critter.climbs() ) {
10328 continue;
10329 }
10330 if( critter.attack_target() == &g->u || ( !critter.has_effect( effect_ridden ) &&
10331 critter.has_effect( effect_pet ) && critter.friendly == -1 &&
10332 !critter.has_effect( effect_tied ) ) ) {
10333 monsters_following.push_back( &critter );
10334 }
10335 }
10336 }
10337
10338 if( u.is_mounted() ) {
10339 monster *crit = u.mounted_creature.get();
10340 if( crit->has_flag( MF_RIDEABLE_MECH ) ) {
10341 crit->use_mech_power( -1 );
10342 if( u.movement_mode_is( CMM_WALK ) ) {
10343 crit->use_mech_power( -2 );
10344 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
10345 crit->use_mech_power( -1 );
10346 } else if( u.movement_mode_is( CMM_RUN ) ) {
10347 crit->use_mech_power( -3 );
10348 }
10349 }
10350 } else {
10351 u.moves -= move_cost;
10352 }
10353 for( const auto &np : npcs_to_bring ) {
10354 if( np->in_vehicle ) {
10355 m.unboard_vehicle( np->pos() );
10356 }
10357 }
10358 const tripoint old_pos = g->u.pos();
10359 point submap_shift;
10360 vertical_shift( z_after );
10361 if( !force ) {
10362 submap_shift = update_map( stairs.x, stairs.y );
10363 }
10364
10365 // if an NPC or monster is on the stiars when player ascends/descends
10366 // they may end up merged on th esame tile, do some displacement to resolve that.
10367 // if, in the weird case of it not being possible to displace;
10368 // ( how did the player even manage to approach the stairs, if so? )
10369 // then nothing terrible happens, its just weird.
10370 if( critter_at<npc>( u.pos(), true ) || critter_at<monster>( u.pos(), true ) ) {
10371 std::string crit_name;
10372 bool player_displace = false;
10374 if( displace.has_value() ) {
10375 npc *guy = g->critter_at<npc>( u.pos(), true );
10376 if( guy ) {
10377 crit_name = guy->get_name();
10378 tripoint old_pos = guy->pos();
10379 if( !guy->is_enemy() ) {
10380 guy->move_away_from( u.pos(), true );
10381 if( old_pos != guy->pos() ) {
10382 add_msg( _( "%s moves out of the way for you." ), guy->get_name() );
10383 }
10384 } else {
10385 player_displace = true;
10386 }
10387 }
10388 monster *mon = g->critter_at<monster>( u.pos(), true );
10389 // if the monster is ridden by the player or an NPC:
10390 // Dont displace them. If they are mounted by a friendly NPC,
10391 // then the NPC will already have been displaced just above.
10392 // if they are ridden by the player, we want them to coexist on same tile
10393 if( mon && !mon->mounted_player ) {
10394 crit_name = mon->get_name();
10395 if( mon->friendly == -1 ) {
10396 mon->setpos( *displace );
10397 add_msg( _( "Your %s moves out of the way for you." ), mon->get_name() );
10398 } else {
10399 player_displace = true;
10400 }
10401 }
10402 if( player_displace ) {
10403 u.setpos( *displace );
10404 u.moves -= 20;
10405 add_msg( _( "You push past %s blocking the way." ), crit_name );
10406 }
10407 } else {
10408 debugmsg( "Failed to find a spot to displace into." );
10409 }
10410 }
10411
10412 // Now that we know the player's destination position, we can move their mount as well
10413 if( u.is_mounted() ) {
10414 if( stored_mount ) {
10415 assert( !m.has_zlevels() );
10416 stored_mount->spawn( g->u.pos() );
10417 if( critter_tracker->add( stored_mount ) ) {
10418 u.mounted_creature = stored_mount;
10419 }
10420 } else {
10421 u.mounted_creature->setpos( g->u.pos() );
10422 }
10423 }
10424
10425 if( !npcs_to_bring.empty() ) {
10426 // Would look nicer randomly scrambled
10427 std::vector<tripoint> candidates = closest_points_first( u.pos(), 1 );
10428 candidates.erase( std::remove_if( candidates.begin(), candidates.end(),
10429 [this]( const tripoint & c ) {
10430 return !is_empty( c );
10431 } ), candidates.end() );
10432
10433 for( const auto &np : npcs_to_bring ) {
10434 const auto found = std::find_if( candidates.begin(), candidates.end(),
10435 [this, np]( const tripoint & c ) {
10436 return !np->is_dangerous_fields( m.field_at( c ) ) && m.tr_at( c ).is_benign();
10437 } );
10438 if( found != candidates.end() ) {
10439 // TODO: De-uglify
10440 np->setpos( *found );
10441 np->place_on_map();
10442 np->setpos( *found );
10443 candidates.erase( found );
10444 }
10445
10446 if( candidates.empty() ) {
10447 break;
10448 }
10449 }
10450
10451 reload_npcs();
10452 }
10453
10454 // This ugly check is here because of stair teleport bullshit
10455 // TODO: Remove stair teleport bullshit
10456 if( rl_dist( g->u.pos(), old_pos ) <= 1 ) {
10457 for( monster *m : monsters_following ) {
10458 m->set_dest( g->u.pos() );
10459 }
10460 }
10461
10462 if( rope_ladder ) {
10463 m.ter_set( u.pos(), t_rope_up );
10464 }
10465
10466 if( m.ter( stairs ) == t_manhole_cover ) {
10467 m.spawn_item( stairs + point( rng( -1, 1 ), rng( -1, 1 ) ), itype_manhole_cover );
10468 m.ter_set( stairs, t_manhole );
10469 }
10470
10471 // Wouldn't work and may do strange things
10472 if( u.is_hauling() && !m.has_zlevels() ) {
10473 add_msg( _( "You cannot haul items here." ) );
10474 u.stop_hauling();
10475 }
10476
10477 if( u.is_hauling() ) {
10478 const tripoint adjusted_pos = old_pos - sm_to_ms_copy( submap_shift );
10479 start_hauling( adjusted_pos );
10480 }
10481
10482 m.invalidate_map_cache( g->get_levz() );
10483 // Upon force movement, traps can not be avoided.
10484 m.creature_on_trap( u, !force );
10485
10487}
static int move_cost(const item &it, const tripoint &src, const tripoint &dest)
@ CMM_WALK
Definition: character.h:102
@ CMM_CROUCH
Definition: character.h:104
bool move_effects(bool attacking) override
Processes effects which may prevent the Character from moving (bear traps, crushed,...
Definition: character.cpp:1535
int swim_speed() const
Returns the player's speed for swimming across water tiles.
Definition: character.cpp:882
int oxygen
Definition: character.h:1530
void mutation_spend_resources(const trait_id &mut)
Removes the appropriate costs (NOTE: will reapply mods & recalc sightlines in case of newly activated...
Definition: mutation.cpp:1723
int shoe_type_count(const itype_id &it) const
Returns 1 if the player is wearing an item of that count on one foot, 2 if on both,...
Definition: character.cpp:8952
std::string get_name() const override
Definition: character.cpp:6095
void start_hauling(const tripoint &pos)
Definition: game.cpp:10489
cata::optional< tripoint > find_or_make_stairs(map &mp, int z_after, bool &rope_ladder, bool peeking)
Returns the other end of the stairs (if any).
Definition: game.cpp:10524
bool use_mech_power(int amt)
Definition: monster.cpp:2393
Character * mounted_player
Definition: monster.h:461
void set_underwater(bool)
Definition: player.cpp:516
static const efftype_id effect_tied("tied")
static const itype_id itype_manhole_cover("manhole_cover")
static const skill_id skill_melee("melee")
static cata::optional< tripoint > point_selection_menu(const std::vector< tripoint > &pts)
Definition: game.cpp:10028
static const itype_id itype_swim_fins("swim_fins")
static const trait_id trait_WEB_ROPE("WEB_ROPE")
ter_id t_rope_up
Definition: mapdata.cpp:719
ter_id t_manhole
Definition: mapdata.cpp:718
bool can_use_mutation_warn(const trait_id &mut, const Character &character)
Calls can_use_mutation and if it fails, print a standard message.
Definition: mutation.cpp:1712
void avatar_moves(const avatar &u, const map &m, const tripoint &p)
Definition: game.cpp:12147
int ladder(player *, item *, bool, const tripoint &)
Definition: iuse.cpp:9353
int climbing_cost(const map &m, const tripoint &from, const tripoint &to)
Checks both the neighborhoods of from and to for climbable surfaces, returns move cost of climbing fr...
point displace(type dir, int dist=1)
Returns point(0, 0) displaced in specified direction by a specified distance.
Definition: overmap.cpp:4177

References _, active_npc, add_msg(), all_monsters(), cata_event_dispatch::avatar_moves(), c, can_use_mutation_warn(), map_funcs::climbing_cost(), closest_points_first(), CMM_CROUCH, CMM_RUN, CMM_WALK, coming_to_stairs, map::creature_on_trap(), critter_tracker, debugmsg, Character::dex_cur, dice(), om_direction::displace(), effect_pet, effect_ridden, effect_tied, find_empty_spot_nearby(), find_or_make_stairs(), monster::friendly, g, get_levx(), get_levy(), get_levz(), Character::get_name(), monster::get_name(), Character::get_skill_level(), avatar::grab(), player::grab_point, map::has_flag(), monster::has_flag(), map::has_floor_or_support(), Character::has_trait(), map::has_zlevels(), map::invalidate_map_cache(), npc::is_enemy(), Character::is_hauling(), Character::is_mounted(), Creature::is_underwater(), itype_manhole_cover, itype_swim_fins, iuse::ladder(), map::load(), m, m_bad, m_good, m_info, m_warning, MF_RIDEABLE_MECH, Creature::mod_moves(), monstairz, Character::mounted_creature, monster::mounted_player, npc::move_away_from(), move_cost(), Character::move_effects(), Character::movement_mode_is(), Creature::moves, Character::mutation_spend_resources(), om_direction::name(), OBJECT_NONE, OVERMAP_HEIGHT, Character::oxygen, map::passable(), point_selection_menu(), map::points_in_radius(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), query_yn(), reload_npcs(), remove_zombie(), rl_dist(), rng(), player::set_underwater(), Character::setpos(), monster::setpos(), shift_monsters(), Character::shoe_type_count(), skill_dodge, skill_melee, sm_to_ms_copy(), map::spawn_item(), start_hauling(), Character::stop_hauling(), Character::str_cur, Character::swim_speed(), t_manhole, t_manhole_cover, t_rope_up, map::ter(), map::ter_set(), map::tername(), TFLAG_DEEP_WATER, trait_WEB_ROPE, tripoint_zero, u, map::unboard_vehicle(), update_map(), update_stair_monsters(), monster::use_mech_power(), vertical_move(), vertical_shift(), Character::worn_with_flag(), tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by handle_action(), peek(), and vertical_move().

◆ vertical_notes()

void game::vertical_notes ( int  z_before,
int  z_after 
)

Add goes up/down auto_notes (if turned on)

Definition at line 10711 of file game.cpp.

10712{
10713 if( z_before == z_after || !get_option<bool>( "AUTO_NOTES" ) ||
10714 !get_option<bool>( "AUTO_NOTES_STAIRS" ) ) {
10715 return;
10716 }
10717
10718 if( !m.inbounds_z( z_before ) || !m.inbounds_z( z_after ) ) {
10719 debugmsg( "game::vertical_notes invalid arguments: z_before == %d, z_after == %d",
10720 z_before, z_after );
10721 return;
10722 }
10723 // Figure out where we know there are up/down connectors
10724 // Fill in all the tiles we know about (e.g. subway stations)
10725 static const int REVEAL_RADIUS = 40;
10726 for( const tripoint_abs_omt &p : points_in_radius( u.global_omt_location(), REVEAL_RADIUS ) ) {
10727 const tripoint_abs_omt cursp_before( p.xy(), z_before );
10728 const tripoint_abs_omt cursp_after( p.xy(), z_after );
10729
10730 if( !overmap_buffer.seen( cursp_before ) ) {
10731 continue;
10732 }
10733 if( overmap_buffer.has_note( cursp_after ) ) {
10734 // Already has a note -> never add an AUTO-note
10735 continue;
10736 }
10737 const oter_id &ter = overmap_buffer.ter( cursp_before );
10738 const oter_id &ter2 = overmap_buffer.ter( cursp_after );
10739 if( z_after > z_before && ter->has_flag( known_up ) &&
10740 !ter2->has_flag( known_down ) ) {
10741 overmap_buffer.set_seen( cursp_after, true );
10742 overmap_buffer.add_note( cursp_after, string_format( ">:W;%s", _( "AUTO: goes down" ) ) );
10743 } else if( z_after < z_before && ter->has_flag( known_down ) &&
10744 !ter2->has_flag( known_up ) ) {
10745 overmap_buffer.set_seen( cursp_after, true );
10746 overmap_buffer.add_note( cursp_after, string_format( "<:W;%s", _( "AUTO: goes up" ) ) );
10747 }
10748 }
10749}
bool inbounds_z(const int z) const
Definition: map.h:1673
void add_note(const tripoint_abs_omt &, const std::string &message)
@ known_up
Definition: omdata.h:87
@ known_down
Definition: omdata.h:86
bool has_flag(oter_flags flag) const
Definition: omdata.h:258

References _, overmapbuffer::add_note(), debugmsg, Character::global_omt_location(), oter_t::has_flag(), overmapbuffer::has_note(), map::inbounds_z(), known_down, known_up, m, overmap_buffer, points_in_radius(), overmapbuffer::seen(), overmapbuffer::set_seen(), string_format(), overmapbuffer::ter(), and u.

Referenced by vertical_shift().

◆ vertical_shift()

void game::vertical_shift ( int  z_after)

Actual z-level movement part of vertical_move.

Doesn't include stair finding, traps etc.

Definition at line 10674 of file game.cpp.

10675{
10676 if( z_after < -OVERMAP_DEPTH || z_after > OVERMAP_HEIGHT ) {
10677 debugmsg( "Tried to get z-level %d outside allowed range of %d-%d",
10678 z_after, -OVERMAP_DEPTH, OVERMAP_HEIGHT );
10679 return;
10680 }
10681
10682 // TODO: Implement dragging stuff up/down
10683 u.grab( OBJECT_NONE );
10684
10685 scent.reset();
10686
10687 u.setz( z_after );
10688 const int z_before = get_levz();
10689 if( !m.has_zlevels() ) {
10691 m.access_cache( z_before ).vehicle_list.clear();
10692 m.access_cache( z_before ).zone_vehicles.clear();
10693 m.access_cache( z_before ).map_memory_seen_cache.reset();
10694 m.set_transparency_cache_dirty( z_before );
10695 m.set_outside_cache_dirty( z_before );
10696 m.load( tripoint( get_levx(), get_levy(), z_after ), true );
10697 shift_monsters( tripoint( 0, 0, z_after - z_before ) );
10698 reload_npcs();
10699 } else {
10700 // Shift the map itself
10701 m.vertical_shift( z_after );
10702 }
10703
10704 m.spawn_monsters( true );
10705 // this may be required after a vertical shift if z-levels are not enabled
10706 // the critter is unloaded/loaded, and it needs to reconstruct its rider data after being reloaded.
10708 vertical_notes( z_before, z_after );
10709}
void setz(int z)
Definition: character.h:794
void vertical_notes(int z_before, int z_after)
Add goes up/down auto_notes (if turned on)
Definition: game.cpp:10711
void set_transparency_cache_dirty(const int zlev)
Sets a dirty flag on the a given cache.
Definition: map.h:410
void set_outside_cache_dirty(const int zlev)
Definition: map.h:447
void vertical_shift(int newz)
Moves the map vertically to (not by!) newz.
Definition: map.cpp:6909
std::set< vehicle * > zone_vehicles
Definition: map.h:363
std::set< vehicle * > vehicle_list
Definition: map.h:362

References map::access_cache(), map::clear_vehicle_cache(), debugmsg, get_levx(), get_levy(), get_levz(), avatar::grab(), map::has_zlevels(), map::load(), m, level_cache::map_memory_seen_cache, OBJECT_NONE, OVERMAP_DEPTH, OVERMAP_HEIGHT, reload_npcs(), scent_map::reset(), scent, map::set_outside_cache_dirty(), map::set_transparency_cache_dirty(), Character::setz(), shift_monsters(), map::spawn_monsters(), u, validate_mounted_npcs(), level_cache::vehicle_list, vertical_notes(), map::vertical_shift(), and level_cache::zone_vehicles.

Referenced by place_player(), and vertical_move().

◆ walk_move()

bool game::walk_move ( const tripoint dest,
bool  via_ramp = false 
)

TODO: This should really use the mounted creatures stamina, if mounted. Monsters don't currently have stamina however. For the time being just don't burn players stamina when mounted.

Dexterity decreases chance of tentacles getting stuck to the ground Intelligence decreases chance of tentacles getting stuck to the ground

Definition at line 8868 of file game.cpp.

8869{
8870 if( m.has_flag_ter( TFLAG_SMALL_PASSAGE, dest_loc ) ) {
8871 if( u.get_size() > MS_MEDIUM ) {
8872 add_msg( m_warning, _( "You can't fit there." ) );
8873 return false; // character too large to fit through a tight passage
8874 }
8875 if( u.is_mounted() ) {
8876 monster *mount = u.mounted_creature.get();
8877 if( mount->get_size() > MS_MEDIUM ) {
8878 add_msg( m_warning, _( "Your mount can't fit there." ) );
8879 return false; // char's mount is too large for tight passages
8880 }
8881 }
8882 }
8883
8884 if( u.is_mounted() ) {
8885 auto mons = u.mounted_creature.get();
8886 if( mons->has_flag( MF_RIDEABLE_MECH ) ) {
8887 if( !mons->check_mech_powered() ) {
8888 add_msg( m_bad, _( "Your %s refuses to move as its batteries have been drained." ),
8889 mons->get_name() );
8890 return false;
8891 }
8892 }
8893 if( !mons->move_effects( false ) ) {
8894 add_msg( m_bad, _( "You cannot move as your %s isn't able to move." ), mons->get_name() );
8895 return false;
8896 }
8897 }
8898 const optional_vpart_position vp_here = m.veh_at( u.pos() );
8899 const optional_vpart_position vp_there = m.veh_at( dest_loc );
8900
8901 bool pushing = false; // moving -into- grabbed tile; skip check for move_cost > 0
8902 bool pulling = false; // moving -away- from grabbed tile; check for move_cost > 0
8903 bool shifting_furniture = false; // moving furniture and staying still; skip check for move_cost > 0
8904
8905 const tripoint furn_pos = u.pos() + u.grab_point;
8906 const tripoint furn_dest = dest_loc + u.grab_point;
8907
8908 bool grabbed = u.get_grab_type() != OBJECT_NONE;
8909 if( grabbed ) {
8910 const tripoint dp = dest_loc - u.pos();
8911 pushing = dp == u.grab_point;
8912 pulling = dp == -u.grab_point;
8913 }
8914 if( grabbed && dest_loc.z != u.posz() ) {
8915 add_msg( m_warning, _( "You let go of the grabbed object." ) );
8916 grabbed = false;
8917 u.grab( OBJECT_NONE );
8918 }
8919
8920 // Now make sure we're actually holding something
8921 const vehicle *grabbed_vehicle = nullptr;
8922 if( grabbed && u.get_grab_type() == OBJECT_FURNITURE ) {
8923 // We only care about shifting, because it's the only one that can change our destination
8924 if( m.has_furn( u.pos() + u.grab_point ) ) {
8925 shifting_furniture = !pushing && !pulling;
8926 } else {
8927 // We were grabbing a furniture that isn't there
8928 grabbed = false;
8929 }
8930 } else if( grabbed && u.get_grab_type() == OBJECT_VEHICLE ) {
8931 grabbed_vehicle = veh_pointer_or_null( m.veh_at( u.pos() + u.grab_point ) );
8932 if( grabbed_vehicle == nullptr ) {
8933 // We were grabbing a vehicle that isn't there anymore
8934 grabbed = false;
8935 }
8936 } else if( grabbed ) {
8937 // We were grabbing something WEIRD, let's pretend we weren't
8938 grabbed = false;
8939 }
8940 if( u.grab_point != tripoint_zero && !grabbed ) {
8941 add_msg( m_warning, _( "Can't find grabbed object." ) );
8942 u.grab( OBJECT_NONE );
8943 }
8944
8945 if( m.impassable( dest_loc ) && !pushing && !shifting_furniture ) {
8946 if( vp_there && u.mounted_creature && u.mounted_creature->has_flag( MF_RIDEABLE_MECH ) &&
8947 vp_there->vehicle().handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
8948 tripoint diff = dest_loc - u.pos();
8949 if( diff.x < 0 ) {
8950 diff.x -= 2;
8951 } else if( diff.x > 0 ) {
8952 diff.x += 2;
8953 }
8954 if( diff.y < 0 ) {
8955 diff.y -= 2;
8956 } else if( diff.y > 0 ) {
8957 diff.y += 2;
8958 }
8959 u.mounted_creature->shove_vehicle( dest_loc + diff.xy(),
8960 dest_loc );
8961 }
8962 return false;
8963 }
8964 if( vp_there && !vp_there->vehicle().handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
8965 return false;
8966 }
8967 if( u.is_mounted() && !pushing && vp_there ) {
8968 add_msg( m_warning, _( "You cannot board a vehicle whilst riding." ) );
8969 return false;
8970 }
8971 u.set_underwater( false );
8972
8973 if( !shifting_furniture && !pushing && is_dangerous_tile( dest_loc ) ) {
8974 std::vector<std::string> harmful_stuff = get_dangerous_tile( dest_loc );
8975 const auto dangerous_terrain_opt = get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" );
8976 const auto harmful_text = enumerate_as_string( harmful_stuff );
8977 const auto warn_msg = [&]( const char *const msg ) {
8978 add_msg( m_warning, msg, harmful_text );
8979 };
8980
8981 if( dangerous_terrain_opt == "IGNORE" ) {
8982 warn_msg( _( "Stepping into that %1$s looks risky, but you enter anyway." ) );
8983 } else if( dangerous_terrain_opt == "ALWAYS" && !prompt_dangerous_tile( dest_loc ) ) {
8984 return true;
8985 } else if( dangerous_terrain_opt == "RUNNING" &&
8986 ( !u.movement_mode_is( CMM_RUN ) || !prompt_dangerous_tile( dest_loc ) ) ) {
8987 warn_msg( _( "Stepping into that %1$s looks risky. Run into it if you wish to enter anyway." ) );
8988 return true;
8989 } else if( dangerous_terrain_opt == "CROUCHING" &&
8990 ( !u.movement_mode_is( CMM_CROUCH ) || !prompt_dangerous_tile( dest_loc ) ) ) {
8991 warn_msg( _( "Stepping into that %1$s looks risky. Crouch and move into it if you wish to enter anyway." ) );
8992 return true;
8993 } else if( dangerous_terrain_opt == "NEVER" && !u.movement_mode_is( CMM_RUN ) ) {
8994 warn_msg( _( "Stepping into that %1$s looks risky. Run into it if you wish to enter anyway." ) );
8995 return true;
8996 }
8997 }
8998 // Used to decide whether to print a 'moving is slow message
8999 const int mcost_from = m.move_cost( u.pos() ); //calculate this _before_ calling grabbed_move
9000
9001 int modifier = 0;
9002 if( grabbed && u.get_grab_type() == OBJECT_FURNITURE && u.pos() + u.grab_point == dest_loc ) {
9003 modifier = -m.furn( dest_loc ).obj().movecost;
9004 }
9005
9006 int multiplier = 1;
9007 if( u.is_on_ground() ) {
9008 multiplier *= 3;
9009 }
9010
9011 const int mcost = m.combined_movecost( u.pos(), dest_loc, grabbed_vehicle, modifier,
9012 via_ramp ) * multiplier;
9013 if( grabbed_move( dest_loc - u.pos() ) ) {
9014 return true;
9015 } else if( mcost == 0 ) {
9016 return false;
9017 }
9018 bool diag = trigdist && u.posx() != dest_loc.x && u.posy() != dest_loc.y;
9019 const int previous_moves = u.moves;
9020 if( u.is_mounted() ) {
9021 auto crit = u.mounted_creature.get();
9022 if( !crit->has_flag( MF_RIDEABLE_MECH ) &&
9023 ( m.has_flag_ter_or_furn( "MOUNTABLE", dest_loc ) ||
9024 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR", dest_loc ) ||
9025 m.has_flag_ter_or_furn( "OPENCLOSE_INSIDE", dest_loc ) ||
9026 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR_DAMAGED", dest_loc ) ||
9027 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR_REINFORCED", dest_loc ) ) ) {
9028 add_msg( m_warning, _( "You cannot pass obstacles whilst mounted." ) );
9029 return false;
9030 }
9031 const double base_moves = u.run_cost( mcost, diag ) * 100.0 / crit->get_speed();
9032 const double encumb_moves = u.get_weight() / 4800.0_gram;
9033 u.moves -= static_cast<int>( std::ceil( base_moves + encumb_moves ) );
9034 if( u.movement_mode_is( CMM_WALK ) ) {
9035 crit->use_mech_power( -2 );
9036 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
9037 crit->use_mech_power( -1 );
9038 } else if( u.movement_mode_is( CMM_RUN ) ) {
9039 crit->use_mech_power( -3 );
9040 }
9041 } else {
9042 u.moves -= u.run_cost( mcost, diag );
9043 /**
9044 TODO:
9045 This should really use the mounted creatures stamina, if mounted.
9046 Monsters don't currently have stamina however.
9047 For the time being just don't burn players stamina when mounted.
9048 */
9049 if( grabbed_vehicle == nullptr || grabbed_vehicle->wheelcache.empty() ) {
9050 //Burn normal amount of stamina if no vehicle grabbed or vehicle lacks wheels
9051 u.burn_move_stamina( previous_moves - u.moves );
9052 } else {
9053 //Burn half as much stamina if vehicle has wheels, without changing move time
9054 u.burn_move_stamina( 0.50 * ( previous_moves - u.moves ) );
9055 }
9056 }
9057 // Max out recoil & reset aim point
9060
9061 // Print a message if movement is slow
9062 const int mcost_to = m.move_cost( dest_loc ); //calculate this _after_ calling grabbed_move
9063 const bool fungus = m.has_flag_ter_or_furn( "FUNGUS", u.pos() ) ||
9064 m.has_flag_ter_or_furn( "FUNGUS",
9065 dest_loc ); //fungal furniture has no slowing effect on mycus characters
9066 const bool slowed = ( ( !u.has_trait( trait_PARKOUR ) && ( mcost_to > 2 || mcost_from > 2 ) ) ||
9067 mcost_to > 4 || mcost_from > 4 ) &&
9068 !( u.has_trait( trait_M_IMMUNE ) && fungus );
9069 if( slowed && !u.is_mounted() ) {
9070 // Unless u.pos() has a higher movecost than dest_loc, state that dest_loc is the cause
9071 if( mcost_to >= mcost_from ) {
9072 if( auto displayed_part = vp_there.part_displayed() ) {
9073 add_msg( m_warning, _( "Moving onto this %s is slow!" ),
9074 displayed_part->part().name() );
9075 sfx::do_obstacle( displayed_part->part().info().get_id().str() );
9076 } else {
9077 add_msg( m_warning, _( "Moving onto this %s is slow!" ), m.name( dest_loc ) );
9078 sfx::do_obstacle( m.ter( dest_loc ).id().str() );
9079 }
9080 } else {
9081 if( auto displayed_part = vp_here.part_displayed() ) {
9082 add_msg( m_warning, _( "Moving off of this %s is slow!" ),
9083 displayed_part->part().name() );
9084 sfx::do_obstacle( displayed_part->part().info().get_id().str() );
9085 } else {
9086 add_msg( m_warning, _( "Moving off of this %s is slow!" ), m.name( u.pos() ) );
9087 sfx::do_obstacle( m.ter( u.pos() ).id().str() );
9088 }
9089 }
9090 }
9091 if( !u.is_mounted() && u.has_trait( trait_id( "LEG_TENT_BRACE" ) ) &&
9092 ( !u.footwear_factor() ||
9093 ( u.footwear_factor() == .5 && one_in( 2 ) ) ) ) {
9094 // DX and IN are long suits for Cephalopods,
9095 // so this shouldn't cause too much hardship
9096 // Presumed that if it's swimmable, they're
9097 // swimming and won't stick
9098 ///\EFFECT_DEX decreases chance of tentacles getting stuck to the ground
9099
9100 ///\EFFECT_INT decreases chance of tentacles getting stuck to the ground
9101 if( !m.has_flag( "SWIMMABLE", dest_loc ) && one_in( 80 + u.dex_cur + u.int_cur ) ) {
9102 add_msg( _( "Your tentacles stick to the ground, but you pull them free." ) );
9103 u.mod_fatigue( 1 );
9104 }
9105 }
9106 if( !u.has_artifact_with( AEP_STEALTH ) && !u.has_trait( trait_id( "DEBUG_SILENT" ) ) ) {
9107 int volume = u.is_stealthy() ? 3 : 6;
9108 volume *= u.mutation_value( "noise_modifier" );
9109 if( volume > 0 ) {
9111 volume = 2;
9112 } else if( u.has_bionic( bionic_id( "bio_ankles" ) ) ) {
9113 volume = 12;
9114 }
9115 if( u.movement_mode_is( CMM_RUN ) ) {
9116 volume *= 1.5;
9117 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
9118 volume /= 2;
9119 }
9120 if( u.is_mounted() ) {
9121 auto mons = u.mounted_creature.get();
9122 switch( mons->get_size() ) {
9123 case MS_TINY:
9124 volume = 0; // No sound for the tinies
9125 break;
9126 case MS_SMALL:
9127 volume /= 3;
9128 break;
9129 case MS_MEDIUM:
9130 break;
9131 case MS_LARGE:
9132 volume *= 1.5;
9133 break;
9134 case MS_HUGE:
9135 volume *= 2;
9136 break;
9137 default:
9138 break;
9139 }
9140 if( mons->has_flag( MF_LOUDMOVES ) ) {
9141 volume += 6;
9142 }
9143 sounds::sound( dest_loc, volume, sounds::sound_t::movement, mons->type->get_footsteps(), false,
9144 "none", "none" );
9145 } else {
9146 sounds::sound( dest_loc, volume, sounds::sound_t::movement, _( "footsteps" ), true,
9147 "none", "none" ); // Sound of footsteps may awaken nearby monsters
9148 }
9150 }
9151
9152 if( one_in( 20 ) && u.has_artifact_with( AEP_MOVEMENT_NOISE ) ) {
9153 sounds::sound( u.pos(), 40, sounds::sound_t::movement, _( "a rattling sound." ), true,
9154 "misc", "rattling" );
9155 }
9156 }
9157
9158 if( m.has_flag_ter_or_furn( TFLAG_HIDE_PLACE, dest_loc ) ) {
9159 add_msg( m_good, _( "You are hiding in the %s." ), m.name( dest_loc ) );
9160 }
9161
9162 if( dest_loc != u.pos() ) {
9164 }
9165
9166 tripoint oldpos = u.pos();
9167 point submap_shift = place_player( dest_loc );
9168 point ms_shift = sm_to_ms_copy( submap_shift );
9169 oldpos = oldpos - ms_shift;
9170
9171 if( pulling ) {
9172 const tripoint shifted_furn_pos = furn_pos - ms_shift;
9173 const tripoint shifted_furn_dest = furn_dest - ms_shift;
9174 const time_duration fire_age = m.get_field_age( shifted_furn_pos, fd_fire );
9175 const int fire_intensity = m.get_field_intensity( shifted_furn_pos, fd_fire );
9176 m.remove_field( shifted_furn_pos, fd_fire );
9177 m.set_field_intensity( shifted_furn_dest, fd_fire, fire_intensity );
9178 m.set_field_age( shifted_furn_dest, fd_fire, fire_age );
9179 }
9180
9181 if( u.is_hauling() ) {
9182 start_hauling( oldpos );
9183 }
9184
9186
9187 return true;
9188}
void burn_move_stamina(int moves)
Definition: character.cpp:7223
virtual bool has_artifact_with(art_effect_passive effect) const
Definition: character.cpp:3220
units::mass get_weight() const override
Returns body weight plus weight of inventory and worn/wielded items.
Definition: character.cpp:3664
bool is_on_ground() const override
Returns true if the player is knocked over or has broken legs.
Definition: character.cpp:962
float mutation_value(const std::string &val) const
Goes over all mutations, gets min and max of a value with given name.
Definition: character.cpp:6751
int run_cost(int base_cost, bool diag=false) const
Returns the player's modified base movement cost.
m_size get_size() const override
Get size class of character.
Definition: character.cpp:541
bool is_wearing(const item &itm) const
Returns true if the player is wearing the item.
Definition: character.cpp:3240
bool grabbed_move(const tripoint &dp)
Check for dangerous stuff at dest_loc, return false if the player decides not to step there.
Definition: game.cpp:9794
bool is_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:8797
const string_id< T > & id() const
Definition: ammo_effect.cpp:33
int combined_movecost(const tripoint &from, const tripoint &to, const vehicle *ignored_vehicle=nullptr, int modifier=0, bool flying=false, bool via_ramp=false) const
Cost to move out of one tile and into the next.
Definition: map.cpp:1838
m_size get_size() const override
Definition: monster.cpp:2693
cata::optional< vpart_reference > part_displayed() const
Definition: vehicle.cpp:2498
bool is_stealthy() const
Returns true if the player has stealthy movement.
cata::optional< tripoint > last_target_pos
Definition: player.h:598
@ MS_TINY
Definition: creature.h:58
@ MS_LARGE
Definition: creature.h:61
@ MS_MEDIUM
Definition: creature.h:60
static const itype_id itype_rm13_armor_on("rm13_armor_on")
static const trait_id trait_M_IMMUNE("M_IMMUNE")
@ TFLAG_SMALL_PASSAGE
Definition: mapdata.h:320
@ TFLAG_HIDE_PLACE
Definition: mapdata.h:315
@ MF_LOUDMOVES
Definition: mtype.h:175
void fungus(player &p, const tripoint &examp)
Remove furniture.
Definition: iexamine.cpp:2199
void do_obstacle(const std::string &obst="")
Definition: sounds.cpp:1635
void do_footstep()
Definition: sounds.cpp:1612

References _, add_msg(), AEP_MOVEMENT_NOISE, AEP_STEALTH, cata_event_dispatch::avatar_moves(), Character::burn_move_stamina(), CMM_CROUCH, CMM_RUN, CMM_WALK, map::combined_movecost(), Character::dex_cur, sfx::do_footstep(), sfx::do_obstacle(), enumerate_as_string(), fd_fire, Character::footwear_factor(), iexamine::fungus(), map::furn(), get_dangerous_tile(), map::get_field_age(), map::get_field_intensity(), avatar::get_grab_type(), Character::get_size(), monster::get_size(), Character::get_weight(), avatar::grab(), player::grab_point, grabbed_move(), Character::has_artifact_with(), Character::has_bionic(), map::has_flag(), map::has_flag_ter(), map::has_flag_ter_or_furn(), map::has_furn(), Character::has_trait(), int_id< T >::id(), map::impassable(), Character::int_cur, is_dangerous_tile(), Character::is_hauling(), Character::is_mounted(), Character::is_on_ground(), player::is_stealthy(), Character::is_wearing(), itype_rm13_armor_on, player::last_target_pos, m, m_bad, m_good, m_warning, MAX_RECOIL, MF_LOUDMOVES, MF_RIDEABLE_MECH, Character::mod_fatigue(), Character::mounted_creature, map::move_cost(), map_data_common_t::movecost, sounds::movement, Character::movement_mode_is(), Creature::moves, MS_HUGE, MS_LARGE, MS_MEDIUM, MS_SMALL, MS_TINY, Character::mutation_value(), map::name(), cata::nullopt, int_id< T >::obj(), OBJECT_FURNITURE, OBJECT_NONE, OBJECT_VEHICLE, on_move_effects(), one_in(), optional_vpart_position::part_displayed(), place_player(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), prompt_dangerous_tile(), Character::recoil, map::remove_field(), Character::run_cost(), map::set_field_age(), map::set_field_intensity(), player::set_underwater(), sm_to_ms_copy(), sounds::sound(), start_hauling(), string_id< T >::str(), map::ter(), TFLAG_HIDE_PLACE, TFLAG_SMALL_PASSAGE, trait_M_IMMUNE, trait_PARKOUR, trigdist, tripoint_zero, u, map::veh_at(), veh_pointer_or_null(), vehicle::wheelcache, tripoint::x, tripoint::xy(), tripoint::y, and tripoint::z.

Referenced by swap_critters().

◆ win()

void game::win ( )

Marks the game as won.

Doesn't end the game.

Definition at line 2530 of file game.cpp.

2531{
2532 win_screen();
2534 memorial().add(
2535 pgettext( "memorial_male", "Closed the portal in %1$.1f days (%2$d seconds)." ),
2536 pgettext( "memorial_female", "Closed the portal in %1$.1f days (%2$d seconds)." ),
2537 to_days<float>( game_duration ), to_seconds<int>( game_duration ) );
2538 if( !u.is_dead_state() ) {
2541 }
2542}
void win_screen()
Definition: game.cpp:2544
void add(const std::string &male_msg, const std::string &female_msg)
Adds an event to the memorial log, to be written to the memorial file when the character dies.
const time_point & start_of_game
Definition: calendar.cpp:34

References achievements_tracker_ptr, memorial_logger::add(), Messages::display_messages(), get_kill_tracker(), player::is_dead_state(), memorial(), pgettext(), show_scores_ui(), calendar::start_of_game, stats(), calendar::turn, u, and win_screen().

◆ win_screen()

void game::win_screen ( )
private

Definition at line 2544 of file game.cpp.

2545{
2546 // TODO: Move this wall somewhere
2548 std::string msg = _( "You managed to close the portal and end the invasion!" );
2549 msg += '\n';
2550 if( u.is_dead_state() ) {
2552 "Unfortunately, you had to sacrifice your life to achieve this." );
2553 msg += colorize( t, c_red ) + '\n';
2554 memorial().add(
2555 pgettext( "memorial_male", "Sacrificed his life to close the portal." ),
2556 pgettext( "memorial_female", "Sacrificed her life to close the portal." ) );
2557 } else {
2558 translation t = translation::to_translation( "win_game", "You managed to survive the ordeal." );
2559 msg += colorize( t, c_green ) + '\n';
2560 memorial().add(
2561 pgettext( "memorial_male", "Safely closed the portal." ),
2562 pgettext( "memorial_female", "Safely closed the portal." ) );
2563 }
2564 msg += string_format( _( "It took you %1$.1f days (%2$d seconds)." ),
2565 to_days<float>( game_duration ), to_seconds<int>( game_duration ) );
2566 // TODO: Print starting stats, traits, skills, all mods ever used, easiest of settings
2567 popup( msg );
2568}
Class for storing translation context and raw string for deferred translation.
Definition: translations.h:152
static translation to_translation(const std::string &raw)
Store a string, an optional plural form, and an optional context for translation.
std::string colorize(const std::string &text, const nc_color &color)
Definition: color.cpp:669

References _, memorial_logger::add(), c_green, c_red, colorize(), player::is_dead_state(), memorial(), pgettext(), popup(), calendar::start_of_game, string_format(), translation::to_translation(), calendar::turn, and u.

Referenced by win().

◆ write_memorial_file()

void game::write_memorial_file ( const std::string &  filename,
std::string  sLastWords 
)

Writes information about the character out to a text file timestamped with the time of the file was made.

This serves as a record of the character's state at the time the memorial was made (usually upon death) and accomplishments in a human-readable format.

Definition at line 2933 of file game.cpp.

2934{
2935 const std::string &memorial_dir = PATH_INFO::memorialdir();
2936 const std::string &memorial_active_world_dir = memorial_dir +
2937 world_generator->active_world->world_name + "/";
2938
2939 //Check if both dirs exist. Nested assure_dir_exist fails if the first dir of the nested dir does not exist.
2940 if( !assure_dir_exist( memorial_dir ) ) {
2941 debugmsg( "Could not make '%s' directory", memorial_dir );
2942 return;
2943 }
2944
2945 if( !assure_dir_exist( memorial_active_world_dir ) ) {
2946 debugmsg( "Could not make '%s' directory", memorial_active_world_dir );
2947 return;
2948 }
2949
2950 std::string path = memorial_active_world_dir + filename + ".txt";
2951
2952 write_to_file( path, [&]( std::ostream & fout ) {
2953 memorial().write( fout, sLastWords );
2954 }, _( "player memorial" ) );
2955}
void write(std::ostream &memorial_file, const std::string &epitaph) const
std::string memorialdir()
Definition: path_info.cpp:226

References _, assure_dir_exist(), debugmsg, memorial(), PATH_INFO::memorialdir(), world_generator, memorial_logger::write(), and write_to_file().

Referenced by cleanup_at_end().

◆ zones_manager()

void game::zones_manager ( )

Definition at line 6208 of file game.cpp.

6209{
6210 const tripoint stored_view_offset = u.view_offset;
6211
6213
6214 const int zone_ui_height = 12;
6215 const int zone_options_height = 7;
6216
6217 const int width = 45;
6218
6219 int offsetX = 0;
6220 int max_rows = 0;
6221
6222 catacurses::window w_zones;
6223 catacurses::window w_zones_border;
6224 catacurses::window w_zones_info;
6225 catacurses::window w_zones_info_border;
6226 catacurses::window w_zones_options;
6227
6228 bool show = true;
6229
6230 ui_adaptor ui;
6231 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
6232 if( !show ) {
6233 ui.position( point_zero, point_zero );
6234 return;
6235 }
6236 offsetX = get_option<std::string>( "SIDEBAR_POSITION" ) != "left" ?
6237 TERMX - width : 0;
6238 const int w_zone_height = TERMY - zone_ui_height;
6239 max_rows = w_zone_height - 2;
6240 w_zones = catacurses::newwin( w_zone_height - 2, width - 2,
6241 point( offsetX + 1, 1 ) );
6242 w_zones_border = catacurses::newwin( w_zone_height, width,
6243 point( offsetX, 0 ) );
6244 w_zones_info = catacurses::newwin( zone_ui_height - zone_options_height - 1,
6245 width - 2, point( offsetX + 1, w_zone_height ) );
6246 w_zones_info_border = catacurses::newwin( zone_ui_height, width,
6247 point( offsetX, w_zone_height ) );
6248 w_zones_options = catacurses::newwin( zone_options_height - 1, width - 2,
6249 point( offsetX + 1, TERMY - zone_options_height ) );
6250
6251 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
6252 } );
6253 ui.mark_resize();
6254
6255 std::string action;
6256 input_context ctxt( "ZONES_MANAGER" );
6257 ctxt.register_cardinal();
6258 ctxt.register_action( "CONFIRM" );
6259 ctxt.register_action( "QUIT" );
6260 ctxt.register_action( "ADD_ZONE" );
6261 ctxt.register_action( "REMOVE_ZONE" );
6262 ctxt.register_action( "MOVE_ZONE_UP" );
6263 ctxt.register_action( "MOVE_ZONE_DOWN" );
6264 ctxt.register_action( "SHOW_ZONE_ON_MAP" );
6265 ctxt.register_action( "ENABLE_ZONE" );
6266 ctxt.register_action( "DISABLE_ZONE" );
6267 ctxt.register_action( "SHOW_ALL_ZONES" );
6268 ctxt.register_action( "HELP_KEYBINDINGS" );
6269
6270 auto &mgr = zone_manager::get_manager();
6271 int start_index = 0;
6272 int active_index = 0;
6273 bool blink = false;
6274 bool stuff_changed = false;
6275 bool show_all_zones = false;
6276 int zone_cnt = 0;
6277
6278 // get zones on the same z-level, with distance between player and
6279 // zone center point <= 50 or all zones, if show_all_zones is true
6280 auto get_zones = [&]() {
6281 std::vector<zone_manager::ref_zone_data> zones;
6282 if( show_all_zones ) {
6283 zones = mgr.get_zones();
6284 } else {
6285 const tripoint &u_abs_pos = m.getabs( u.pos() );
6286 for( zone_manager::ref_zone_data &ref : mgr.get_zones() ) {
6287 const tripoint &zone_abs_pos = ref.get().get_center_point();
6288 if( u_abs_pos.z == zone_abs_pos.z && rl_dist( u_abs_pos, zone_abs_pos ) <= 50 ) {
6289 zones.emplace_back( ref );
6290 }
6291 }
6292 }
6293 zone_cnt = static_cast<int>( zones.size() );
6294 return zones;
6295 };
6296
6297 auto zones = get_zones();
6298
6299 auto zones_manager_options = [&]() {
6300 werase( w_zones_options );
6301
6302 if( zone_cnt > 0 ) {
6303 const auto &zone = zones[active_index].get();
6304
6305 if( zone.has_options() ) {
6306 const auto &descriptions = zone.get_options().get_descriptions();
6307
6308 // NOLINTNEXTLINE(cata-use-named-point-constants)
6309 mvwprintz( w_zones_options, point( 1, 0 ), c_white, _( "Options" ) );
6310
6311 int y = 1;
6312 for( const auto &desc : descriptions ) {
6313 mvwprintz( w_zones_options, point( 3, y ), c_white, desc.first );
6314 mvwprintz( w_zones_options, point( 20, y ), c_white, desc.second );
6315 y++;
6316 }
6317 }
6318 }
6319
6320 wnoutrefresh( w_zones_options );
6321 };
6322
6323 cata::optional<tripoint> zone_start;
6324 cata::optional<tripoint> zone_end;
6325 bool zone_blink = false;
6326 bool zone_cursor = false;
6328 zone_start, zone_end, zone_blink, zone_cursor );
6329 add_draw_callback( zone_cb );
6330
6331 auto query_position =
6332 [&]() -> cata::optional<std::pair<tripoint, tripoint>> {
6333 on_out_of_scope invalidate_current_ui( [&]()
6334 {
6335 ui.mark_resize();
6336 } );
6337 restore_on_out_of_scope<bool> show_prev( show );
6338 restore_on_out_of_scope<cata::optional<tripoint>> zone_start_prev( zone_start );
6339 restore_on_out_of_scope<cata::optional<tripoint>> zone_end_prev( zone_end );
6340 show = false;
6341 zone_start = cata::nullopt;
6342 zone_end = cata::nullopt;
6343 ui.mark_resize();
6344
6346 popup.on_top( true );
6347 popup.message( "%s", _( "Select first point." ) );
6348
6350
6351 const look_around_result first = look_around( /*show_window=*/false, center, center, false, true,
6352 false );
6353 if( first.position )
6354 {
6355 popup.message( "%s", _( "Select second point." ) );
6356
6357 const look_around_result second = look_around( /*show_window=*/false, center, *first.position,
6358 true, true, false );
6359 if( second.position ) {
6360 tripoint first_abs = m.getabs( tripoint( std::min( first.position->x,
6361 second.position->x ),
6362 std::min( first.position->y, second.position->y ),
6363 std::min( first.position->z,
6364 second.position->z ) ) );
6365 tripoint second_abs = m.getabs( tripoint( std::max( first.position->x,
6366 second.position->x ),
6367 std::max( first.position->y, second.position->y ),
6368 std::max( first.position->z,
6369 second.position->z ) ) );
6370 return std::pair<tripoint, tripoint>( first_abs, second_abs );
6371 }
6372 }
6373
6374 return cata::nullopt;
6375 };
6376
6377 ui.on_redraw( [&]( const ui_adaptor & ) {
6378 if( !show ) {
6379 return;
6380 }
6381 zones_manager_draw_borders( w_zones_border, w_zones_info_border, zone_ui_height, width );
6382 zones_manager_shortcuts( w_zones_info );
6383
6384 if( zone_cnt == 0 ) {
6385 werase( w_zones );
6386 mvwprintz( w_zones, point( 2, 5 ), c_white, _( "No Zones defined." ) );
6387
6388 } else {
6389 werase( w_zones );
6390
6391 calcStartPos( start_index, active_index, max_rows, zone_cnt );
6392
6393 draw_scrollbar( w_zones_border, active_index, max_rows, zone_cnt, point_south );
6394 wnoutrefresh( w_zones_border );
6395
6396 int iNum = 0;
6397
6398 tripoint player_absolute_pos = m.getabs( u.pos() );
6399
6400 //Display saved zones
6401 for( auto &i : zones ) {
6402 if( iNum >= start_index &&
6403 iNum < start_index + ( ( max_rows > zone_cnt ) ? zone_cnt : max_rows ) ) {
6404 const auto &zone = i.get();
6405
6406 nc_color colorLine = ( zone.get_enabled() ) ? c_white : c_light_gray;
6407
6408 if( iNum == active_index ) {
6409 mvwprintz( w_zones, point( 0, iNum - start_index ), c_yellow, "%s", ">>" );
6410 colorLine = ( zone.get_enabled() ) ? c_light_green : c_green;
6411 }
6412
6413 //Draw Zone name
6414 mvwprintz( w_zones, point( 3, iNum - start_index ), colorLine,
6415 trim_by_length( zone.get_name(), 15 ) );
6416
6417 //Draw Type name
6418 mvwprintz( w_zones, point( 20, iNum - start_index ), colorLine,
6419 mgr.get_name_from_type( zone.get_type() ) );
6420
6421 tripoint center = zone.get_center_point();
6422
6423 //Draw direction + distance
6424 mvwprintz( w_zones, point( 32, iNum - start_index ), colorLine, "%*d %s",
6425 5, static_cast<int>( trig_dist( player_absolute_pos, center ) ),
6426 direction_name_short( direction_from( player_absolute_pos,
6427 center ) ) );
6428
6429 //Draw Vehicle Indicator
6430 mvwprintz( w_zones, point( 41, iNum - start_index ), colorLine,
6431 zone.get_is_vehicle() ? "*" : "" );
6432 }
6433 iNum++;
6434 }
6435
6436 // Display zone options
6437 zones_manager_options();
6438 }
6439
6440 wnoutrefresh( w_zones );
6441 } );
6442
6443 zones_manager_open = true;
6444 do {
6445 if( action == "ADD_ZONE" ) {
6446 do { // not a loop, just for quick bailing out if canceled
6447 const auto maybe_id = mgr.query_type();
6448 if( !maybe_id.has_value() ) {
6449 break;
6450 }
6451
6452 const zone_type_id &id = maybe_id.value();
6453 auto options = zone_options::create( id );
6454
6455 if( !options->query_at_creation() ) {
6456 break;
6457 }
6458
6459 auto default_name = options->get_zone_name_suggestion();
6460 if( default_name.empty() ) {
6461 default_name = mgr.get_name_from_type( id );
6462 }
6463 const auto maybe_name = mgr.query_name( default_name );
6464 if( !maybe_name.has_value() ) {
6465 break;
6466 }
6467 const std::string &name = maybe_name.value();
6468
6469 const auto position = query_position();
6470 if( !position ) {
6471 break;
6472 }
6473
6474 mgr.add( name, id, g->u.get_faction()->id, false, true, position->first,
6475 position->second, options );
6476
6477 zones = get_zones();
6478 active_index = zone_cnt - 1;
6479
6480 stuff_changed = true;
6481 } while( false );
6482
6483 blink = false;
6484 } else if( action == "SHOW_ALL_ZONES" ) {
6485 show_all_zones = !show_all_zones;
6486 zones = get_zones();
6487 active_index = 0;
6488 } else if( zone_cnt > 0 ) {
6489 if( action == "UP" ) {
6490 active_index--;
6491 if( active_index < 0 ) {
6492 active_index = zone_cnt - 1;
6493 }
6494 blink = false;
6495 } else if( action == "DOWN" ) {
6496 active_index++;
6497 if( active_index >= zone_cnt ) {
6498 active_index = 0;
6499 }
6500 blink = false;
6501 } else if( action == "REMOVE_ZONE" ) {
6502 if( active_index < zone_cnt ) {
6503 mgr.remove( zones[active_index] );
6504 zones = get_zones();
6505 active_index--;
6506
6507 if( active_index < 0 ) {
6508 active_index = 0;
6509 }
6510 }
6511 blink = false;
6512 stuff_changed = true;
6513
6514 } else if( action == "CONFIRM" ) {
6515 auto &zone = zones[active_index].get();
6516
6517 uilist as_m;
6518 as_m.text = _( "What do you want to change:" );
6519 as_m.entries.emplace_back( 1, true, '1', _( "Edit name" ) );
6520 as_m.entries.emplace_back( 2, true, '2', _( "Edit type" ) );
6521 as_m.entries.emplace_back( 3, zone.get_options().has_options(), '3',
6522 zone.get_type() == zone_type_id( "LOOT_CUSTOM" ) ? _( "Edit filter" ) : _( "Edit options" ) );
6523 as_m.entries.emplace_back( 4, !zone.get_is_vehicle(), '4', _( "Edit position" ) );
6524 // TODO: Enable moving vzone after vehicle zone can be bigger than 1*1
6525 as_m.entries.emplace_back( 5, !zone.get_is_vehicle(), '5', _( "Move position" ) );
6526 as_m.query();
6527
6528 switch( as_m.ret ) {
6529 case 1:
6530 if( zone.set_name() ) {
6531 stuff_changed = true;
6532 }
6533 break;
6534 case 2:
6535 if( zone.set_type() ) {
6536 stuff_changed = true;
6537 }
6538 break;
6539 case 3:
6540 if( zone.get_options().query() ) {
6541 stuff_changed = true;
6542 }
6543 break;
6544 case 4: {
6545 const auto pos = query_position();
6546 if( pos && ( pos->first != zone.get_start_point() ||
6547 pos->second != zone.get_end_point() ) ) {
6548 zone.set_position( *pos );
6549 stuff_changed = true;
6550 }
6551 break;
6552 }
6553 case 5: {
6554 on_out_of_scope invalidate_current_ui( [&]() {
6555 ui.mark_resize();
6556 } );
6557 restore_on_out_of_scope<bool> show_prev( show );
6558 restore_on_out_of_scope<cata::optional<tripoint>> zone_start_prev( zone_start );
6559 restore_on_out_of_scope<cata::optional<tripoint>> zone_end_prev( zone_end );
6560 show = false;
6561 zone_start = cata::nullopt;
6562 zone_end = cata::nullopt;
6563 ui.mark_resize();
6564 static_popup message_pop;
6565 message_pop.on_top( true );
6566 message_pop.message( "%s", _( "Moving zone." ) );
6567 const auto zone_local_start_point = m.getlocal( zone.get_start_point() );
6568 const auto zone_local_end_point = m.getlocal( zone.get_end_point() );
6569 // local position of the zone center, used to calculate the u.view_offset,
6570 // could center the screen to the position it represents
6571 auto view_center = m.getlocal( zone.get_center_point() );
6572 const look_around_result result_local = look_around( false, view_center,
6573 zone_local_start_point, false, false,
6574 false, true, zone_local_end_point );
6575 if( result_local.position ) {
6576 const auto new_start_point = m.getabs( *result_local.position );
6577 if( new_start_point == zone.get_start_point() ) {
6578 break; // Nothing changed, don't save
6579 }
6580
6581 const auto new_end_point = zone.get_end_point() - zone.get_start_point() + new_start_point;
6582 zone.set_position( std::pair<tripoint, tripoint>( new_start_point, new_end_point ) );
6583 stuff_changed = true;
6584 }
6585 }
6586 break;
6587 default:
6588 break;
6589 }
6590
6591 blink = false;
6592 } else if( action == "MOVE_ZONE_UP" && zone_cnt > 1 ) {
6593 if( active_index < zone_cnt - 1 ) {
6594 mgr.swap( zones[active_index], zones[active_index + 1] );
6595 zones = get_zones();
6596 active_index++;
6597 }
6598 blink = false;
6599 stuff_changed = true;
6600
6601 } else if( action == "MOVE_ZONE_DOWN" && zone_cnt > 1 ) {
6602 if( active_index > 0 ) {
6603 mgr.swap( zones[active_index], zones[active_index - 1] );
6604 zones = get_zones();
6605 active_index--;
6606 }
6607 blink = false;
6608 stuff_changed = true;
6609
6610 } else if( action == "SHOW_ZONE_ON_MAP" ) {
6611 //show zone position on overmap;
6612 tripoint_abs_omt player_overmap_position = u.global_omt_location();
6613 // TODO: fix point types
6614 tripoint_abs_omt zone_overmap( ms_to_omt_copy( zones[active_index].get().get_center_point() ) );
6615
6616 ui::omap::display_zones( player_overmap_position, zone_overmap, active_index );
6617 } else if( action == "ENABLE_ZONE" ) {
6618 zones[active_index].get().set_enabled( true );
6619
6620 stuff_changed = true;
6621
6622 } else if( action == "DISABLE_ZONE" ) {
6623 zones[active_index].get().set_enabled( false );
6624
6625 stuff_changed = true;
6626 }
6627 }
6628
6629 if( zone_cnt > 0 ) {
6630 blink = !blink;
6631 const auto &zone = zones[active_index].get();
6632 zone_start = m.getlocal( zone.get_start_point() );
6633 zone_end = m.getlocal( zone.get_end_point() );
6634 ctxt.set_timeout( BLINK_SPEED );
6635 } else {
6636 blink = false;
6637 zone_start = zone_end = cata::nullopt;
6638 ctxt.reset_timeout();
6639 }
6640
6641 // Actually accessed from the terrain overlay callback `zone_cb` in the
6642 // call to `ui_manager::redraw`.
6643 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
6644 zone_blink = blink;
6646
6648
6649 //Wait for input
6650 action = ctxt.handle_input();
6651 } while( action != "QUIT" );
6652 zones_manager_open = false;
6653 ctxt.reset_timeout();
6654 zone_cb = nullptr;
6655
6656 if( stuff_changed ) {
6657 auto &zones = zone_manager::get_manager();
6658 if( query_yn( _( "Save changes?" ) ) ) {
6659 zones.save_zones();
6660 } else {
6661 zones.load_zones();
6662 }
6663
6664 zones.cache_data();
6665 }
6666
6667 u.view_offset = stored_view_offset;
6668}
query_popup & on_top(bool top)
Whether to show the popup on the top of the screen.
Definition: popup.cpp:59
std::reference_wrapper< zone_data > ref_zone_data
Definition: clzones.h:342
static shared_ptr_fast< zone_options > create(const zone_type_id &type)
Definition: clzones.cpp:186
int trig_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:512
static void zones_manager_shortcuts(const catacurses::window &w_info)
Definition: game.cpp:6143
static void zones_manager_draw_borders(const catacurses::window &w_border, const catacurses::window &w_info_border, const int iInfoHeight, const int width)
Definition: game.cpp:6166
std::string options()
Definition: path_info.cpp:238
const std::set< itype_id > & get()
void display_zones(const tripoint_abs_omt &center, const tripoint_abs_omt &select, int iZoneIndex)
Display overmap like with display() and display the given zone.
std::string trim_by_length(const std::string &text, int width)
Definition: output.cpp:224
cata::optional< tripoint > position
Definition: game.h:127

References _, action, add_draw_callback(), BLINK_SPEED, c_green, c_light_gray, c_light_green, c_white, c_yellow, calcStartPos(), center, zone_options::create(), create_zone_callback(), direction_from(), direction_name_short(), ui::omap::display_zones(), draw_scrollbar(), uilist::entries, g, charge_removal_blacklist::get(), zone_manager::get_manager(), map::getabs(), map::getlocal(), Character::global_omt_location(), input_context::handle_input(), invalidate_main_ui_adaptor(), look_around(), m, query_popup::message(), ms_to_omt_copy(), mvwprintz(), om_direction::name(), catacurses::newwin(), cata::nullopt, query_popup::on_top(), PATH_INFO::options(), point_south, point_zero, popup(), Character::pos(), look_around_result::position, uilist::query(), query_yn(), ui_manager::redraw(), input_context::register_action(), input_context::register_cardinal(), input_context::reset_timeout(), uilist::ret, rl_dist(), second, input_context::set_timeout(), TERMX, TERMY, uilist::text, trig_dist(), trim_by_length(), tripoint_zero, u, player::view_offset, catacurses::werase(), catacurses::wnoutrefresh(), tripoint::z, zones_manager_draw_borders(), zones_manager_open, and zones_manager_shortcuts().

Referenced by handle_action().

◆ zoom_in()

void game::zoom_in ( )

Definition at line 7170 of file game.cpp.

7171{
7172#if defined(TILES)
7173 if( tileset_zoom == 64 ) {
7174 tileset_zoom = MAXIMUM_ZOOM_LEVEL;
7175 } else {
7177 }
7178 rescale_tileset( tileset_zoom );
7179#endif
7180}

References tileset_zoom.

Referenced by handle_action(), and look_around().

◆ zoom_out()

void game::zoom_out ( )

Definition at line 7158 of file game.cpp.

7159{
7160#if defined(TILES)
7161 if( tileset_zoom > MAXIMUM_ZOOM_LEVEL ) {
7163 } else {
7164 tileset_zoom = 64;
7165 }
7166 rescale_tileset( tileset_zoom );
7167#endif
7168}

References tileset_zoom.

Referenced by handle_action(), and look_around().

Friends And Related Function Documentation

◆ advanced_inventory

friend class advanced_inventory
friend

Definition at line 146 of file game.h.

◆ Creature_range

friend class Creature_range
friend

Definition at line 360 of file game.h.

Referenced by all_creatures().

◆ editmap

friend class editmap
friend

Definition at line 145 of file game.h.

◆ get_avatar

avatar & get_avatar ( )
friend

Definition at line 102 of file avatar.cpp.

103{
104 return g->u;
105}

Referenced by butcher_submenu().

◆ get_distribution_grid_tracker

distribution_grid_tracker & get_distribution_grid_tracker ( )
friend

Returns distribution grid tracker that is a part of the global game *g.

game TODO: This wouldn't be required in an ideal world

Definition at line 12163 of file game.cpp.

12164{
12165 return *g->grid_tracker_ptr;
12166}

◆ get_map

map & get_map ( )
friend

Definition at line 146 of file map.cpp.

147{
148 return g->m;
149}

Referenced by check_art_charge_req(), extended_description(), find_empty_spot_nearby(), get_fire_fuel_string(), and print_terrain_info().

◆ get_player_character

Character & get_player_character ( )
friend

Definition at line 387 of file character.cpp.

388{
389 return g->u;
390}

◆ get_weather

weather_manager & get_weather ( )
friend

Definition at line 64 of file weather.cpp.

65{
66 return *g->weather_manager_ptr;
67}

Referenced by do_turn(), get_player_input(), is_in_sunlight(), load(), natural_light_level(), place_player_overmap(), serialize_master(), setup(), start_game(), and unserialize_master().

◆ main_menu

friend class main_menu
friend

Definition at line 147 of file game.h.

◆ monster_range

friend class monster_range
friend

Definition at line 359 of file game.h.

Referenced by all_monsters().

Member Data Documentation

◆ achievements_tracker_ptr

pimpl<achievements_tracker> game::achievements_tracker_ptr
private

Definition at line 981 of file game.h.

Referenced by death_screen(), game(), handle_action(), serialize(), setup(), unserialize(), and win().

◆ active_npc

◆ auto_travel_mode

bool game::auto_travel_mode = false

Definition at line 1044 of file game.h.

Referenced by handle_action(), serialize(), and unserialize().

◆ bVMonsterLookFire

bool game::bVMonsterLookFire = false
private

Definition at line 1061 of file game.h.

Referenced by list_monsters(), look_around(), and setup().

◆ coming_to_stairs

std::vector<monster> game::coming_to_stairs

◆ critter_died

bool game::critter_died = false
private

Has anything died in this turn and needs to be cleaned up?

Definition at line 1075 of file game.h.

Referenced by cleanup_dead(), and set_critter_died().

◆ critter_tracker

◆ debug_hour_timer

◆ debug_pathfinding

bool game::debug_pathfinding = false

Definition at line 1025 of file game.h.

◆ debug_submap_grid_overlay

bool game::debug_submap_grid_overlay = false

Definition at line 1026 of file game.h.

◆ destination_preview

std::vector<tripoint> game::destination_preview
private

◆ displaying_lighting_condition

int game::displaying_lighting_condition = 0

Type of lighting condition overlay to display.

Definition at line 1038 of file game.h.

◆ displaying_overlays

cata::optional<action_id> game::displaying_overlays
private

Definition at line 945 of file game.h.

Referenced by display_overlay_state(), and display_toggle_overlay().

◆ displaying_visibility_creature

Creature* game::displaying_visibility_creature

Creature for which to display the visibility map.

Definition at line 1036 of file game.h.

Referenced by display_visibility().

◆ draw_callbacks

std::vector<weak_ptr_fast<draw_callback_t> > game::draw_callbacks
private

Definition at line 251 of file game.h.

Referenced by add_draw_callback(), and draw().

◆ driving_view_offset

point game::driving_view_offset

Definition at line 1023 of file game.h.

Referenced by calc_driving_offset(), do_turn(), handle_action(), and set_driving_view_offset().

◆ event_bus_ptr

pimpl<event_bus> game::event_bus_ptr
private

Definition at line 979 of file game.h.

Referenced by events().

◆ faction_manager_ptr

◆ first_redraw_since_waiting_started

bool game::first_redraw_since_waiting_started = true
private

Is this the first redraw since waiting (sleeping or activity) started.

Definition at line 1077 of file game.h.

Referenced by do_turn(), and game().

◆ follower_ids

std::set<character_id> game::follower_ids
private

◆ fullscreen

bool game::fullscreen = false

◆ gamemode

std::unique_ptr<special_game> game::gamemode
private

◆ grid_tracker_ptr

pimpl<distribution_grid_tracker> game::grid_tracker_ptr
private

Definition at line 985 of file game.h.

Referenced by do_turn(), load_map(), on_options_changed(), and update_map().

◆ is_looking

bool game::is_looking = false
private

Definition at line 250 of file game.h.

Referenced by draw_ter(), and look_around().

◆ kill_tracker_ptr

pimpl<kill_tracker> game::kill_tracker_ptr
private

Definition at line 982 of file game.h.

Referenced by game(), get_kill_tracker(), serialize(), setup(), and unserialize().

◆ last_mouse_edge_scroll

std::chrono::time_point<std::chrono::steady_clock> game::last_mouse_edge_scroll
private

Definition at line 1094 of file game.h.

Referenced by mouse_edge_scrolling().

◆ last_mouse_edge_scroll_vector_overmap

tripoint game::last_mouse_edge_scroll_vector_overmap
private

Definition at line 1096 of file game.h.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ last_mouse_edge_scroll_vector_terrain

tripoint game::last_mouse_edge_scroll_vector_terrain
private

Definition at line 1095 of file game.h.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ last_save_timestamp

time_t game::last_save_timestamp
private

Definition at line 1067 of file game.h.

Referenced by autosave(), init_autosave(), and quicksave().

◆ latest_lightlevels

std::array<float, OVERMAP_LAYERS> game::latest_lightlevels
mutableprivate

Definition at line 1068 of file game.h.

Referenced by natural_light_level(), and reset_light_level().

◆ list_item_downvote

std::string game::list_item_downvote
private

Definition at line 1058 of file game.h.

Referenced by list_items().

◆ list_item_upvote

std::string game::list_item_upvote
private

Definition at line 1057 of file game.h.

Referenced by list_items().

◆ liveview

live_view& game::liveview
private

Definition at line 976 of file game.h.

Referenced by draw_look_around_cursor(), and handle_mouseview().

◆ liveview_ptr

pimpl<live_view> game::liveview_ptr
private

Definition at line 975 of file game.h.

◆ m

map& game::m

Definition at line 989 of file game.h.

Referenced by autopilot_vehicles(), cata_event_dispatch::avatar_moves(), butcher(), catch_a_monster(), check_near_zone(), check_zone(), control_vehicle(), disable_robot(), disp_NPCs(), do_turn(), draw(), draw_bullet(), draw_critter(), draw_critter_highlighted(), draw_critter_internal(), draw_hit_mon(), draw_look_around_cursor(), draw_ter(), examine(), extended_description(), find_nearby_items(), find_or_make_stairs(), fling_creature(), forced_door_closing(), get_cur_om(), get_dangerous_tile(), get_fishable_locations(), get_levx(), get_levy(), get_levz(), get_player_input(), get_veh_dir_indicator_location(), grabbed_furn_move(), grabbed_veh_move(), handle_action(), is_empty(), is_game_over(), is_in_sunlight(), is_sheltered(), knockback(), list_items(), list_monsters(), load(), load_map(), load_npcs(), look_around(), mon_info_update(), monmove(), moving_vehicle_dismount(), peek(), perhaps_add_random_npc(), phasing_move(), pickup(), place_critter_around(), place_player(), place_player_overmap(), place_vehicle_nearby(), pre_print_all_tile_info(), print_all_tile_info(), print_fields_info(), print_graffiti_info(), print_items_info(), print_terrain_info(), print_trap_info(), process_artifact(), prompt_dangerous_tile(), remoteveh(), save_cyborg(), save_maps(), serialize(), setup(), shift_monsters(), start_game(), start_hauling(), swap_critters(), try_get_left_click_action(), try_get_right_click_action(), update_map(), update_stair_monsters(), use_computer(), validate_camps(), validate_linked_vehicles(), validate_mounted_npcs(), vertical_move(), vertical_notes(), vertical_shift(), walk_move(), and zones_manager().

◆ main_ui_adaptor

weak_ptr_fast<ui_adaptor> game::main_ui_adaptor
private

◆ map_ptr

pimpl<map> game::map_ptr
private

Definition at line 973 of file game.h.

◆ memorial_logger_ptr

pimpl<memorial_logger> game::memorial_logger_ptr
private

Definition at line 983 of file game.h.

Referenced by game(), and memorial().

◆ monstairz

int game::monstairz = 0

Definition at line 1010 of file game.h.

Referenced by update_stair_monsters(), and vertical_move().

◆ mostseen

int game::mostseen = 0

◆ moves_since_last_save

int game::moves_since_last_save = 0
private

Definition at line 1066 of file game.h.

Referenced by do_turn(), get_moves_since_last_save(), init_autosave(), quickload(), and quicksave().

◆ new_game

bool game::new_game = false

True if the game has just started or loaded, else false.

Definition at line 1006 of file game.h.

Referenced by do_turn(), setup(), and start_game().

◆ next_mission_id

int game::next_mission_id = 0
private

Definition at line 1064 of file game.h.

Referenced by assign_mission_id(), serialize_master(), setup(), and unserialize_master().

◆ next_npc_id

character_id game::next_npc_id
private

Definition at line 1062 of file game.h.

Referenced by assign_npc_id(), serialize_master(), setup(), and unserialize_master().

◆ npcs_dirty

bool game::npcs_dirty = false
private

Has a NPC been spawned since last load?

Definition at line 1073 of file game.h.

Referenced by do_turn(), load_npcs(), and set_npcs_dirty().

◆ queue_screenshot

bool game::queue_screenshot = false

Definition at line 1045 of file game.h.

Referenced by do_turn().

◆ remoteveh_cache

vehicle* game::remoteveh_cache
private

Definition at line 1071 of file game.h.

Referenced by remoteveh(), setremoteveh(), and setup().

◆ remoteveh_cache_time

time_point game::remoteveh_cache_time
private

Definition at line 1070 of file game.h.

Referenced by remoteveh(), setremoteveh(), and setup().

◆ right_sidebar

bool game::right_sidebar = false

Definition at line 1041 of file game.h.

◆ safe_mode

◆ safe_mode_warning_logged

bool game::safe_mode_warning_logged = false
private

Definition at line 1060 of file game.h.

Referenced by check_safe_mode_allowed(), handle_action(), and set_safe_mode().

◆ scen

const scenario* game::scen

Definition at line 1008 of file game.h.

Referenced by start_calendar(), and start_game().

◆ scent

scent_map& game::scent

Definition at line 991 of file game.h.

Referenced by display_scent(), do_turn(), serialize(), setup(), unserialize(), update_map(), and vertical_shift().

◆ scent_ptr

pimpl<scent_map> game::scent_ptr
private

Definition at line 977 of file game.h.

◆ seed

unsigned int game::seed = 0
private

Seed for all the random numbers that should have consistent randomness (weather).

Definition at line 1089 of file game.h.

Referenced by get_seed(), serialize_master(), start_game(), and unserialize_master().

◆ sFilter

std::string game::sFilter
private

Definition at line 1056 of file game.h.

Referenced by list_items(), and reset_item_list_state().

◆ show_panel_adm

bool game::show_panel_adm = false

Definition at line 1040 of file game.h.

Referenced by draw_panels(), and load_static_data().

◆ spell_events_ptr

pimpl<spell_events> game::spell_events_ptr
private

Definition at line 984 of file game.h.

Referenced by game(), and spell_events_subscriber().

◆ stats_tracker_ptr

pimpl<stats_tracker> game::stats_tracker_ptr
private

Definition at line 980 of file game.h.

Referenced by game(), serialize(), stats(), and unserialize().

◆ ter_view_p

tripoint game::ter_view_p

Definition at line 1012 of file game.h.

Referenced by draw(), and draw_ter().

◆ tileset_zoom

int game::tileset_zoom = 0
private

How far the tileset should be zoomed out, 16 is default.

32 is zoomed in by x2, 8 is zoomed out by x0.5

Definition at line 1086 of file game.h.

Referenced by get_zoom(), look_around(), mouse_edge_scrolling_terrain(), reset_zoom(), set_zoom(), zoom_in(), and zoom_out().

◆ timed_event_manager_ptr

pimpl<timed_event_manager> game::timed_event_manager_ptr
private

Definition at line 978 of file game.h.

◆ timed_events

timed_event_manager& game::timed_events

Definition at line 992 of file game.h.

Referenced by do_turn(), natural_light_level(), and setup().

◆ token_provider_ptr

pimpl<drop_token_provider> game::token_provider_ptr

Definition at line 1001 of file game.h.

Referenced by serialize(), setup(), and unserialize().

◆ turnssincelastmon

int game::turnssincelastmon = 0

Definition at line 1047 of file game.h.

Referenced by handle_action(), mon_info_update(), and setup().

◆ u

avatar& game::u

Definition at line 990 of file game.h.

Referenced by add_npc_follower(), autopilot_vehicles(), cata_event_dispatch::avatar_moves(), butcher(), calc_driving_offset(), cancel_activity_or_ignore_query(), cancel_activity_query(), catch_a_monster(), centerlistview(), chat(), check_safe_mode_allowed(), cleanup_at_end(), control_vehicle(), create_starting_npcs(), critter_at(), critter_by_id(), disable_robot(), disp_NPCs(), display_scent(), do_turn(), draw(), draw_critter(), draw_critter_highlighted(), draw_critter_internal(), draw_hit_mon(), draw_line(), draw_look_around_cursor(), draw_minimap(), draw_panels(), draw_ter(), draw_trail_to_square(), draw_veh_dir_indicator(), drop(), drop_in_direction(), exam_vehicle(), examine(), extended_description(), find_nearby_items(), find_or_make_stairs(), fling_creature(), forced_door_closing(), fungal_effects::fungalize(), get_dangerous_tile(), get_player_base_save_path(), get_player_input(), get_veh_dir_indicator_location(), grabbed_furn_move(), grabbed_move(), grabbed_veh_move(), handle_action(), handle_key_blocking_activity(), inv_map_splice(), is_game_over(), is_hostile_within(), is_in_viewport(), item_action_menu(), knockback(), list_items(), list_items_monsters(), list_missions(), list_monsters(), load(), look_around(), mon_info(), mon_info_update(), monmove(), move_save_to_graveyard(), moving_vehicle_dismount(), npc_menu(), on_move_effects(), open_consume_item_menu(), overmap_npc_move(), peek(), perhaps_add_random_npc(), phasing_move(), pickup_feet(), place_player(), place_player_overmap(), print_all_tile_info(), print_creature_info(), print_items_info(), print_terrain_info(), print_trap_info(), process_activity(), process_artifact(), process_voluntary_act_interrupt(), prompt_dangerous_tile(), quickload(), remoteveh(), remove_npc_follower(), save(), save_player_data(), serialize(), set_driving_view_offset(), setremoteveh(), shared_from(), slip_down(), fungal_effects::spread_fungus_one_tile(), start_game(), start_hauling(), toggle_gate(), try_get_left_click_action(), try_get_right_click_action(), unserialize(), update_map(), update_overmap_seen(), update_stair_monsters(), use_computer(), validate_camps(), validate_npc_followers(), vertical_move(), vertical_notes(), vertical_shift(), walk_move(), win(), win_screen(), and zones_manager().

◆ u_ptr

pimpl<avatar> game::u_ptr
private

Definition at line 974 of file game.h.

◆ u_shared_ptr

shared_ptr_fast<player> game::u_shared_ptr
private

Definition at line 1051 of file game.h.

Referenced by shared_from().

◆ uquit

quit_status game::uquit

Used in main.cpp to determine what type of quit is being performed.

Definition at line 1004 of file game.h.

Referenced by cleanup_at_end(), do_turn(), get_player_input(), handle_action(), is_game_over(), and setup().

◆ user_action_counter

int game::user_action_counter = 0
private

Definition at line 1083 of file game.h.

Referenced by get_user_action_counter(), and handle_action().

◆ w_minimap

catacurses::window game::w_minimap

Definition at line 1016 of file game.h.

Referenced by create_or_get_main_ui_adaptor(), and draw_minimap().

◆ w_minimap_ptr

catacurses::window game::w_minimap_ptr
private

Definition at line 1054 of file game.h.

Referenced by create_or_get_main_ui_adaptor().

◆ w_omlegend

catacurses::window game::w_omlegend

Definition at line 1015 of file game.h.

◆ w_overmap

catacurses::window game::w_overmap

Definition at line 1014 of file game.h.

◆ w_pixel_minimap

catacurses::window game::w_pixel_minimap

◆ w_terrain

◆ w_terrain_ptr

catacurses::window game::w_terrain_ptr
private

Definition at line 1053 of file game.h.

Referenced by create_or_get_main_ui_adaptor().

◆ wait_popup

std::unique_ptr<static_popup> game::wait_popup
private

Definition at line 1102 of file game.h.

Referenced by do_turn().

◆ was_fullscreen

bool game::was_fullscreen = false

Definition at line 1043 of file game.h.

Referenced by load_static_data(), reenter_fullscreen(), and temp_exit_fullscreen().

◆ weather_manager_ptr

pimpl<weather_manager> game::weather_manager_ptr
private

Definition at line 986 of file game.h.

◆ zones_manager_open

bool game::zones_manager_open = false
private

Is Zone manager open or not - changes graphics of some zone tiles.

Definition at line 1079 of file game.h.

Referenced by is_zones_manager_open(), and zones_manager().


The documentation for this class was generated from the following files: